home *** CD-ROM | disk | FTP | other *** search
/ Komputer for Alle 2001 #11 / CD 11 (Black) - 2001.iso / FAVORG / FAVO_SRC.ZIP / FavOrgTreeCtl.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  2000-12-19  |  74.6 KB  |  3,125 lines
  1. // FAVORG Version 1.1
  2. // Copyright (c) 2000 Ziff Davis Media, Inc.
  3. // All rights reserved.
  4. // First Published in PC Magazine, US Edition, November 7, 2000.
  5. // Programmer: Patrick Philippot
  6.  
  7. #include "stdafx.h"
  8. #include "MultiselTreeCtrl.h"
  9. #include "FavOrg.h"
  10. #include "FavOrgTreeCtl.h"
  11. #include "ByStateDlg.h"
  12. #include "editurldlg.h"
  13. #include "SelIconDlg.h"
  14. #include <ras.h>
  15.  
  16. #ifdef _DEBUG
  17. #define new DEBUG_NEW
  18. #undef THIS_FILE
  19. static char THIS_FILE[] = __FILE__;
  20. #endif
  21.  
  22. char const g_szLocation[] = "Location: ";
  23. char const g_szUrlExt[] = ".url";
  24. char const g_szStateSection[] = "status";
  25.  
  26. CFavOrgTreeCtl* g_this;
  27.  
  28. /////////////////////////////////////////////////////////////////////////////
  29. // Worker thread checking URLs
  30.  
  31. UINT DoProcessItems(LPVOID pParam)
  32. {
  33.     // This thread handles the Find Dead links and FavIcons function
  34.     // We must initialize COM for this thread
  35.     CoInitialize(NULL);
  36.  
  37.     // We use the global pointer to our CFavOrgTreeCtl to do the job
  38.     g_this->ProcessItems(*((BOOL*) pParam));
  39.  
  40.     CoUninitialize();
  41.     return(0);
  42. }
  43.  
  44. static int CALLBACK CustomCompareProc(LPARAM lParam1, LPARAM lParam2, LPARAM lParamSort)
  45. {
  46.     // lParamSort contains a pointer to the tree control.
  47.     // The lParam of an item is just its handle.
  48.     CTreeCtrl* pTreeCtrl = (CTreeCtrl*) lParamSort;
  49.  
  50.     BOOL bIsFolder1 = lParam1 == ITEM_IS_FOLDER;
  51.     BOOL bIsFolder2 = lParam2 == ITEM_IS_FOLDER;
  52.  
  53.     // The tree is sorted in such a way that folders are 
  54.     // displayed first
  55.     if ((bIsFolder1 & bIsFolder2) || (!bIsFolder1 && !bIsFolder2))
  56.         return 0;
  57.     else if (bIsFolder1 && !bIsFolder2)
  58.         return -1;
  59.     else
  60.         return 1;
  61. }
  62.  
  63.  
  64. /////////////////////////////////////////////////////////////////////////////
  65. // CFavOrgTreeCtl
  66.  
  67. CFavOrgTreeCtl::CFavOrgTreeCtl()
  68. {
  69.     g_this = this;
  70.  
  71.     // Initiliaze object data
  72.     m_dwConnection = 0;
  73.     m_bConnected = FALSE;
  74.     m_bDoNotCheck = FALSE;
  75.     m_bCancel = FALSE;
  76.     m_nNumItems = 0;
  77.     m_bProcessing = FALSE;
  78.     m_bCanRedirect = FALSE;
  79.     m_bDialed = FALSE;
  80.     m_nTimeout = 8000;
  81.     m_hRootItem = NULL;
  82.     m_bLetUserScroll = FALSE;
  83.  
  84.     m_pProgressCtl = NULL;
  85.     m_hLastCtxtItem = NULL;
  86.  
  87.     m_hRasDll = NULL;
  88.     m_pRasEnumEntries = NULL;
  89.     m_pRasEnumConnections = NULL;
  90.  
  91.     m_pInet = new CInternetSession;
  92.  
  93.     CoInitialize(NULL);
  94. }
  95.  
  96. CFavOrgTreeCtl::~CFavOrgTreeCtl()
  97. {
  98.     CoUninitialize();
  99.  
  100.     // Close WININET session
  101.     m_pInet->Close();
  102.     delete m_pInet;
  103.  
  104.     FreeLibrary(m_hRasDll);
  105. }
  106.  
  107.  
  108. BEGIN_MESSAGE_MAP(CFavOrgTreeCtl, CMultiselTreeCtrl)
  109.     //{{AFX_MSG_MAP(CFavOrgTreeCtl)
  110.     ON_WM_DESTROY()
  111.     ON_WM_LBUTTONDOWN()
  112.     ON_WM_RBUTTONDOWN()
  113.     ON_WM_KEYDOWN()
  114.     ON_WM_SETCURSOR()
  115.     ON_WM_LBUTTONDBLCLK()
  116.     ON_NOTIFY_REFLECT(TVN_BEGINLABELEDIT, OnBeginLabelEdit)
  117.     ON_NOTIFY_REFLECT(TVN_ENDLABELEDIT, OnEndLabelEdit)
  118.     ON_NOTIFY_REFLECT(TVN_SELCHANGED, OnSelChanged)
  119.     ON_WM_SETFOCUS()
  120.     ON_WM_VSCROLL()
  121.     ON_WM_HSCROLL()
  122.     //}}AFX_MSG_MAP
  123. END_MESSAGE_MAP()
  124.  
  125.  
  126. /////////////////////////////////////////////////////////////////////////////
  127. // CFavOrgTreeCtl implementation
  128.  
  129. void CFavOrgTreeCtl::Initialize()
  130. {
  131.     // Create Image List with state icons
  132.     m_imgState.Create(16, 16, ILC_COLOR8 | ILC_MASK, 11, 1);
  133.     m_imgStd.Create(16, 16, ILC_COLOR8 | ILC_MASK, 50, 100);
  134.  
  135.     // Dummy icon because the Tree control uses one-based indexes for states
  136.     HICON hIcon;
  137.  
  138.     hIcon = LoadIcon(NULL, IDI_APPLICATION);
  139.     m_imgState.Add(hIcon);
  140.     DestroyIcon(hIcon);
  141.  
  142.     AddStateIcon(IDI_QUESTIONMARK);
  143.     AddStateIcon(IDI_CHECKMARK);
  144.     AddStateIcon(IDI_PAGENONE);
  145.     AddStateIcon(IDI_PAGEMOVED);
  146.     AddStateIcon(IDI_SITENONE);
  147.     AddStateIcon(IDI_TIMEOUT);
  148.     AddStateIcon(IDI_ACCESSDENIED);
  149.     AddStateIcon(IDI_PAGEMOVED_UPDATED);
  150.     AddStateIcon(IDI_UNCHECKED);
  151.     AddStateIcon(IDI_RESET);
  152.     // Image indexes should be 1 to 10 respectively.
  153.  
  154.     // Set both image lists for control
  155.     SetImageList(&m_imgStd, LVSIL_NORMAL);
  156.     SetImageList(&m_imgState, LVSIL_STATE);
  157.  
  158.     // Compute status and info filenames
  159.     GetModuleFileName(AfxGetInstanceHandle(), m_sStatusFile.GetBuffer(MAX_PATH), MAX_PATH);
  160.     m_sStatusFile.ReleaseBuffer();
  161.     m_sStatusFile.Delete(m_sStatusFile.ReverseFind('.') + 1);
  162.     m_sInfoFile = m_sStatusFile;
  163.     m_sStatusFile += "sta";
  164.     m_sInfoFile += "ifo";
  165.  
  166.     // Initialize status map
  167.     CFile logfile;
  168.     if(logfile.Open(m_sStatusFile, CFile::modeRead))
  169.     {
  170.         try
  171.         {
  172.             CArchive ar(&logfile, CArchive::load);
  173.             m_StatusMap.Serialize(ar);
  174.             ar.Close();
  175.             logfile.Close();
  176.         }
  177.  
  178.         catch(CArchiveException* pEx)
  179.         {
  180.             pEx->Delete();
  181.             logfile.Close();
  182.             return;
  183.         }
  184.     }
  185.  
  186.     // Initialize information map
  187.     if(logfile.Open(m_sInfoFile, CFile::modeRead))
  188.     {
  189.         try
  190.         {
  191.             CArchive ar(&logfile, CArchive::load);
  192.             m_InfoMap.Serialize(ar);
  193.             ar.Close();
  194.             logfile.Close();
  195.         }
  196.  
  197.         catch(CArchiveException* pEx)
  198.         {
  199.             pEx->Delete();
  200.             logfile.Close();
  201.             return;
  202.         }
  203.     }
  204. }
  205.  
  206. int CFavOrgTreeCtl::AddStateIcon(int nId)
  207. {
  208.     // Helper adding state icons to image list
  209.     HICON    hIcon;
  210.     int        nIndex;
  211.  
  212.     hIcon = (HICON) LoadImage(AfxGetInstanceHandle(),
  213.                               MAKEINTRESOURCE(nId),
  214.                               IMAGE_ICON,
  215.                               16, 16, NULL);
  216.     nIndex = m_imgState.Add(hIcon);
  217.     DestroyIcon(hIcon);
  218.  
  219.     return nIndex;
  220. }
  221.  
  222. void CFavOrgTreeCtl::PreSubclassWindow() 
  223. {
  224.     Initialize();
  225.     
  226.     CTreeCtrl::PreSubclassWindow();
  227. }
  228.  
  229. // The following functions are just helper functions
  230.  
  231. CProgressCtrl* CFavOrgTreeCtl::SetProgressBar(CProgressCtrl* pProgressBar)
  232. {
  233.     CProgressCtrl* pTemp = m_pProgressCtl;
  234.     m_pProgressCtl = pProgressBar;
  235.  
  236.     return pTemp;
  237. }
  238.  
  239. CStringEx CFavOrgTreeCtl::SetIconStore(CStringEx sIconStore)
  240. {
  241.     CStringEx sTemp = m_sIconStore;
  242.     m_sIconStore = sIconStore;
  243.     m_sIconStore.AddSlash();
  244.  
  245.     return sTemp;
  246. }
  247.  
  248. BOOL CFavOrgTreeCtl::GetConnectState()
  249. {
  250.     if (m_bDoNotCheck)
  251.     // We consider we are connected
  252.         return TRUE;
  253.  
  254.     if (m_hRasDll == NULL)
  255.     {
  256.         m_hRasDll = LoadLibrary("rasapi32.dll");
  257.         if (m_hRasDll == NULL)
  258.         {
  259.             AfxMessageBox(IDS_RASALERTPROMPT, MB_OK | MB_ICONEXCLAMATION, 0);
  260.             return FALSE;
  261.         }
  262.  
  263.         m_pRasEnumEntries = (RASENUMENTRIES) GetProcAddress(m_hRasDll, "RasEnumEntriesA");
  264.         m_pRasEnumConnections = (RASENUMCONNECTIONS) GetProcAddress(m_hRasDll, "RasEnumConnectionsA");
  265.     }
  266.  
  267.     if ((m_pRasEnumEntries == NULL) || (m_pRasEnumConnections == FALSE))
  268.     {
  269.         AfxMessageBox(IDS_RASALERTPROMPT2, MB_OK | MB_ICONEXCLAMATION, 0);
  270.         return FALSE;
  271.     }
  272.  
  273.     LPRASCONN        lpRasConn;
  274.     DWORD            nRet;
  275.     DWORD            cb;
  276.     DWORD            cConnections;
  277.  
  278.     lpRasConn = (LPRASCONN) malloc(sizeof(RASCONN));
  279.     lpRasConn->dwSize = sizeof(RASCONN);
  280.      nRet = m_pRasEnumConnections(lpRasConn, &cb, &cConnections);
  281.     free(lpRasConn);
  282.  
  283.     // Check if we are connected, try to connect if not,
  284.     // and return state of connection
  285.     if (cConnections == 0)
  286.         FvInternetConnect(&m_bDialed);
  287.     else
  288.         m_bConnected = TRUE;
  289.  
  290.     return m_bConnected;
  291. }
  292.  
  293. void CFavOrgTreeCtl::SetConnectCheck(BOOL bNoConnectCheck)
  294. {
  295.     m_bDoNotCheck = bNoConnectCheck;
  296. }
  297.  
  298. BOOL CFavOrgTreeCtl::FvInternetConnect(BOOL* bDialed)
  299. {
  300.     // Try to establish a connection
  301.     DWORD        dwFlags = 0;
  302.     CWaitCursor waitCursor;
  303.  
  304.     *bDialed = FALSE;
  305.     m_bConnected = FALSE;
  306.  
  307.     DWORD            cb;         
  308.     LPRASENTRYNAME    lpRasEntryName;
  309.     DWORD            cEntries;
  310.  
  311.     cb = 0;
  312.     lpRasEntryName = (LPRASENTRYNAME) malloc(sizeof(RASENTRYNAME));
  313.     lpRasEntryName->dwSize = sizeof(RASENTRYNAME);
  314.     m_pRasEnumEntries(NULL, NULL, lpRasEntryName, &cb, &cEntries); 
  315.     free (lpRasEntryName);
  316.  
  317.     // Try to dial or autodial
  318.     if (cEntries > 0)
  319.     {
  320.         m_bConnected = InternetDial(m_hWnd, 
  321.                                     "", 
  322.                                     INTERNET_DIAL_FORCE_PROMPT, 
  323.                                     &m_dwConnection, 0) == ERROR_SUCCESS;
  324.  
  325.         *bDialed = m_bConnected;
  326.     }
  327.  
  328.     return m_bConnected;
  329. }
  330.  
  331. void CFavOrgTreeCtl::OnDestroy() 
  332. {
  333.     ClearItemdata(m_hRootItem);
  334.  
  335.     CTreeCtrl::OnDestroy();
  336.     
  337.     // Disconnecting is allowed only when FavOrg itself established the
  338.     // connection by using autodial.
  339.     if (m_bDialed || (m_dwConnection != 0))
  340.     {
  341.         if (AfxMessageBox(IDS_CLOSECONNECTION, MB_YESNO | MB_ICONEXCLAMATION, 0) != IDYES)
  342.             return;
  343.  
  344.         if (m_dwConnection != 0)
  345.             InternetHangUp(m_dwConnection, 0);
  346.         else if (m_bDialed)
  347.             InternetAutodialHangup(0);
  348.     }
  349. }
  350.  
  351. int CFavOrgTreeCtl::CountShortcuts(CStringEx sRootPath)
  352. {
  353.     // Count total number of shorcuts
  354.     CFileFind    finder;
  355.     CStringEx    sFileSpec, sPath;
  356.     int            nCount = 0;
  357.  
  358.     sFileSpec = sRootPath;
  359.     sFileSpec.AddSlash();
  360.     sFileSpec += CString("*.*");
  361.  
  362.     sPath = sRootPath;
  363.     sPath.AddSlash();
  364.  
  365.     BOOL bOK = finder.FindFile(sFileSpec);
  366.     while (bOK)
  367.     {
  368.         bOK = finder.FindNextFile();
  369.  
  370.         CStringEx sFilename = finder.GetFileName();
  371.  
  372.         if (finder.IsDirectory() && !finder.IsDots())
  373.         {
  374.             CString sDir = sPath + sFilename;
  375.             nCount += CountShortcuts(sDir);
  376.         }
  377.         else if (!finder.IsDirectory() && (sFilename.GetExtension().CompareNoCase(g_szUrlExt) == 0))
  378.         // We are looking for .URL files only
  379.             nCount++;
  380.  
  381.         PeekAndYield();
  382.     }
  383.  
  384.     return nCount;
  385. }
  386.  
  387. void CFavOrgTreeCtl::LoadFavorites(CString sIniFilename)
  388. {
  389.     BOOL static bWarned = FALSE;
  390.  
  391.     LPITEMIDLIST pItemList;
  392.  
  393.     m_bProcessing = TRUE;
  394.     m_nFolderIconSel = -1;
  395.     m_nFolderIconNotSel = -1;
  396.     m_nStdIconNotSel = -1;
  397.  
  398.     // Get location of Favorites folder
  399.     SHGetSpecialFolderLocation (m_hWnd, CSIDL_FAVORITES, &pItemList);
  400.     SHGetPathFromIDList(pItemList, m_sFavPath.GetBuffer(MAX_PATH)); 
  401.     m_sFavPath.ReleaseBuffer();
  402.  
  403.     int nType = GetDriveType(m_sFavPath.Left(3));
  404.  
  405.     if (!bWarned
  406.          &&
  407.         ((GetDriveType(m_sFavPath.Left(3)) == DRIVE_REMOTE)
  408.           ||
  409.         (m_sFavPath.Left(2).CompareNoCase("\\\\") == 0)))
  410.     {
  411.         AfxMessageBox(IDS_NETWORKALERT, MB_OK | MB_ICONEXCLAMATION, 0);
  412.         bWarned = TRUE;
  413.     }
  414.  
  415.     int nNumItems = CountShortcuts(m_sFavPath);
  416.     m_nNumItems = 0;
  417.  
  418.     // Initialize progress bar
  419.     if (m_pProgressCtl)
  420.     {
  421.         m_pProgressCtl->SetRange32(0, nNumItems);
  422.         m_pProgressCtl->SetStep(1);
  423.         m_pProgressCtl->SetPos(0);
  424.     }
  425.  
  426.     // Clear Tree control
  427.     ClearSelection(TRUE);
  428.     if (m_hRootItem)
  429.         ClearItemdata(m_hRootItem);
  430.     DeleteAllItems();
  431.     ImageList_RemoveAll(m_imgStd.m_hImageList);
  432.     m_imgStd.DeleteImageList();
  433.     m_imgStd.Create(16, 16, ILC_COLOR8 | ILC_MASK, 50, 100);
  434.  
  435.     // Create root item
  436.     CString sRootItem;
  437.  
  438.     sRootItem.Format(IDS_FAVORITES, m_sFavPath);
  439.     // Recursively constructs tree
  440.     m_bLetUserScroll = FALSE;
  441.     m_hRootItem = InsertItem(sRootItem);
  442.     SetItemData(m_hRootItem, ITEM_IS_FOLDER);
  443.  
  444.     SetRedraw(FALSE);
  445.  
  446.     AddItemsFromPath(m_hRootItem, m_sFavPath, sIniFilename);
  447.  
  448.     m_nLoadedItems = m_nNumItems;
  449.     m_nNumItems = nNumItems;
  450.  
  451.     TVSORTCB tvs;
  452.     // Sort the tree control's items using a 
  453.     // custom callback procedure.
  454.     tvs.hParent = m_hRootItem;
  455.     tvs.lpfnCompare = CustomCompareProc;
  456.     tvs.lParam = (LPARAM) this;
  457.     SortChildren(m_hRootItem);
  458.     SortChildrenCB(&tvs);
  459.  
  460.     SetRedraw(TRUE);
  461.     EnsureVisible(m_hRootItem);
  462.     Expand(m_hRootItem, TVE_EXPAND);
  463.  
  464.     SelectItem(NULL);
  465.  
  466.     if (m_pProgressCtl)
  467.         m_pProgressCtl->SetPos(0);
  468.     ClearMsg();
  469.  
  470.     SetCursor(LoadCursor(NULL, IDC_ARROW));
  471.     m_bProcessing = FALSE;
  472.     m_bCancel = FALSE;
  473. }
  474.  
  475. void CFavOrgTreeCtl::AddItemsFromPath(HTREEITEM hParent, CString sRootPath, CString sIniFilename)
  476. {
  477.     if (hParent != NULL)
  478.     {
  479.         CFileFind    finder;
  480.         CStringEx    sFileSpec, sPath;
  481.  
  482.         sFileSpec = sRootPath;
  483.         sFileSpec.AddSlash();
  484.         sFileSpec += CString("*.*");
  485.  
  486.         sPath = sRootPath;
  487.         sPath.AddSlash();
  488.  
  489.         DisplayMsg(IDS_MSG_FROMFOLDER, sRootPath);
  490.  
  491.         BOOL bOK = finder.FindFile(sFileSpec);
  492.         while ((!m_bCancel) && bOK)
  493.         {
  494.             bOK = finder.FindNextFile();
  495.  
  496.             CStringEx sFilename = finder.GetFileName();
  497.  
  498.             // We exclude the Channels folder
  499.             if (finder.IsDirectory() 
  500.                 && 
  501.                 (sFilename.CompareNoCase("Channels") != 0) 
  502.                 && 
  503.                 !finder.IsDots())
  504.             {
  505.                 CString sDir = sPath + sFilename;
  506.                 HTREEITEM hItem = AddItem(sDir, hParent, sIniFilename, TRUE);
  507.                 AddItemsFromPath(hItem, sDir, sIniFilename);
  508.  
  509.                 TVSORTCB tvs;
  510.                 // Sort the tree control's items using my
  511.                 // callback procedure.
  512.                 tvs.hParent = hItem;
  513.                 tvs.lpfnCompare = CustomCompareProc;
  514.                 tvs.lParam = (LPARAM) this;
  515.  
  516.                 //SetRedraw(FALSE);
  517.                 SortChildren(hItem);
  518.                 SortChildrenCB(&tvs);
  519.  
  520.                 CString sItemName = MakeFullItemName(hItem, FALSE);
  521.                 int nState;
  522.  
  523.                 sItemName.MakeUpper();
  524.                 if (!m_StatusMap.Lookup(sItemName, nState))
  525.                     nState = TVIS_EXPANDED;
  526.                 SetItemState(hItem, nState, TVIS_EXPANDED);
  527.                 if (GetItemState(hItem, TVIS_EXPANDED) == TVIS_EXPANDED)
  528.                     Expand(hItem, TVE_EXPAND);
  529.                 else
  530.                     Expand(hItem, TVE_COLLAPSE);
  531.             }
  532.             else if (!finder.IsDirectory() 
  533.                      && 
  534.                      (sFilename.GetExtension().CompareNoCase(g_szUrlExt) == 0))
  535.                 AddItem(sPath + sFilename, hParent, sIniFilename);
  536.         }
  537.     }
  538. }
  539.  
  540. HTREEITEM CFavOrgTreeCtl::AddItem(CStringEx sPath, HTREEITEM hParent, CString sIniFilename, bool bIsDir, int nIcon, int nIcon2)
  541. {
  542.     //SHFILEINFO    shinfo, shinfo_sel;
  543.     int            nIconNotSel, nIconSel;
  544.  
  545.     PeekAndYield();
  546.  
  547.     if (bIsDir)
  548.     // It's a folder - Use SHGetFileInfo to retrieve icon
  549.     {
  550.         if (m_nFolderIconNotSel == -1) // Otherwise, we already have the icons
  551.         {
  552.             /*
  553.             // We need to retrieve the folder icons only once
  554.             SHGetFileInfo(sPath, 
  555.                           NULL,
  556.                           &shinfo, 
  557.                           sizeof(shinfo), 
  558.                           SHGFI_ICON | SHGFI_SMALLICON);
  559.  
  560.             SHGetFileInfo(sPath,
  561.                           NULL, 
  562.                           &shinfo_sel, 
  563.                           sizeof(shinfo_sel), 
  564.                           SHGFI_ICON | SHGFI_OPENICON | SHGFI_SMALLICON);
  565.  
  566.             m_nFolderIconNotSel = m_imgStd.Add(shinfo.hIcon);
  567.             */
  568.             HICON hIcon = LoadIcon(AfxGetInstanceHandle(), MAKEINTRESOURCE(IDI_FOLDER));
  569.             m_nFolderIconNotSel = m_imgStd.Add(hIcon);
  570.             DestroyIcon(hIcon);
  571.  
  572.             hIcon = LoadIcon(AfxGetInstanceHandle(), MAKEINTRESOURCE(IDI_FOLDERSEL));
  573.             m_nFolderIconSel = m_imgStd.Add(hIcon);
  574.             DestroyIcon(hIcon);
  575.  
  576.             SetItemImage(m_hRootItem, m_nFolderIconNotSel, m_nFolderIconSel);
  577.         }
  578.  
  579.         nIconNotSel = nIcon != -1 ? nIcon : m_nFolderIconNotSel;
  580.         nIconSel = nIcon2 != -1 ? nIcon2 : m_nFolderIconSel;
  581.     }
  582.     else
  583.     // It's a shortcut - use COM to retrieve icon
  584.     {
  585.         IUniformResourceLocatorPtr pUrlLink(CLSID_InternetShortcut, NULL, CLSCTX_INPROC_SERVER);
  586.         if (pUrlLink != NULL)
  587.         {
  588.             IShellLinkPtr psl(pUrlLink);
  589.             IPersistFilePtr ppf(pUrlLink);  
  590.         
  591.             if (ppf != NULL)
  592.             { 
  593.                 WCHAR wsz[MAX_PATH];
  594.  
  595.                 MultiByteToWideChar(CP_ACP, 0, sPath, -1, wsz, MAX_PATH);
  596.                 // Load the shortcut. 
  597.                 if (SUCCEEDED(ppf->Load(wsz, STGM_READ)))
  598.                 {
  599.                     int        nIndex;
  600.                     CString    sIconFile;
  601.                     HICON    hIconLarge, hIconSmall;
  602.  
  603.                     // Get icon path
  604.                     psl->GetIconLocation(sIconFile.GetBuffer(MAX_PATH), MAX_PATH, &nIndex);
  605.                     sIconFile.ReleaseBuffer();
  606.  
  607.                     // Get icon / "standard" icon?
  608.                     BOOL bStdIcon = (sIconFile.Right(7).CompareNoCase("url.dll") == 0) && (nIndex == 0);
  609.  
  610.                     if ((m_nStdIconNotSel == -1) || !bStdIcon)
  611.                     {
  612.                         ExtractIconEx(sIconFile, nIndex, &hIconLarge, &hIconSmall, 1);
  613.  
  614.                         if (hIconSmall == NULL)
  615.                         {
  616.                             hIconSmall = hIconLarge;
  617.                             hIconLarge = NULL;
  618.                         }
  619.  
  620.                         if (hIconSmall != NULL)
  621.                         {
  622.                             if (bStdIcon)
  623.                             {
  624.                                 m_nStdIconNotSel = m_imgStd.Add(hIconSmall);
  625.                                 nIconNotSel = nIcon != -1 ? nIcon : m_nStdIconNotSel;
  626.                             }
  627.                             else
  628.                                 nIconNotSel = nIcon != -1 ? nIcon : m_imgStd.Add(hIconSmall);
  629.  
  630.                             nIconSel = nIcon2 != -1 ? nIcon2 : nIconNotSel;
  631.                             DestroyIcon(hIconSmall);
  632.                         }
  633.                         else
  634.                         {
  635.                             nIconSel = m_nStdIconNotSel;
  636.                             nIconNotSel = m_nStdIconNotSel;
  637.                         }
  638.  
  639.                         if (hIconLarge != NULL)
  640.                             DestroyIcon(hIconLarge);
  641.                     }
  642.                     else    // We already have the standard icon
  643.                     {
  644.                         nIconNotSel = m_nStdIconNotSel;
  645.                         nIconSel = m_nStdIconNotSel;
  646.                     }
  647.                 }
  648.             }
  649.         }
  650.     }
  651.  
  652.     HTREEITEM hItem;
  653.     CString sDrive, sDir, sName, sExt;
  654.  
  655.     CStringEx::SplitPath(sPath, sDrive, sDir, sName, sExt, bIsDir);
  656.  
  657.     if (bIsDir)
  658.     {
  659.         // Add folder to tree
  660.         hItem = InsertItem(TVIF_TEXT | TVIF_STATE | TVIF_SELECTEDIMAGE | TVIF_PARAM | TVIF_IMAGE | TVIF_HANDLE,
  661.                            sName, 
  662.                            nIconNotSel, 
  663.                            nIconSel, 
  664.                            0,
  665.                            0,
  666.                            ITEM_IS_FOLDER, 
  667.                            hParent,
  668.                            TVI_LAST);
  669.         // Mark item as folder
  670.         SetItemData(hItem, ITEM_IS_FOLDER);
  671.     }
  672.     else
  673.     {
  674.         CString sItemName = MakeFullItemName(hParent, FALSE);
  675.         int nState;
  676.  
  677.         sItemName += "\\";
  678.         sItemName += sName + sExt;
  679.  
  680.         // Get item status if stored in status map
  681.         sItemName.MakeUpper();
  682.         if (!m_StatusMap.Lookup(sItemName, nState))
  683.             nState = INDEXTOSTATEIMAGEMASK(STATE_INDEX_UNCHECKED);
  684.  
  685.         // Add item to tree
  686.         hItem = InsertItem(TVIF_TEXT | TVIF_STATE | TVIF_SELECTEDIMAGE | TVIF_PARAM | TVIF_IMAGE | TVIF_HANDLE,
  687.                            sName, 
  688.                            nIconNotSel, 
  689.                            nIconSel, 
  690.                            nState,
  691.                            TVIS_STATEIMAGEMASK, 
  692.                            0, 
  693.                            hParent,
  694.                            TVI_LAST);
  695.  
  696.         if (hItem)
  697.         {
  698.             CString* psData = new CString(); // leak
  699.             if (m_InfoMap.Lookup(sItemName, *psData))
  700.                 SetItemData(hItem, (DWORD) psData);
  701.             else
  702.                 delete psData;
  703.  
  704.             if (m_pProgressCtl)
  705.                 m_pProgressCtl->OffsetPos(1);
  706.             m_nNumItems++;
  707.         }
  708.     }
  709.  
  710.     return     hItem;
  711. }
  712.  
  713. CString CFavOrgTreeCtl::MakeFullItemName(HTREEITEM hItem, BOOL bIsShortcut)
  714. {
  715.     // Compute the full item path from the name of its 
  716.     // parents in the tree
  717.     CString        sFullItemName;
  718.     HTREEITEM    hCurItem;
  719.  
  720.     hCurItem = hItem;
  721.  
  722.     while(hCurItem != m_hRootItem)
  723.     {
  724.         sFullItemName = CString("\\") + GetItemText(hCurItem) + sFullItemName;
  725.         hCurItem = GetParentItem(hCurItem);
  726.     }
  727.     
  728.     // Now, we are at the root
  729.     sFullItemName = m_sFavPath + sFullItemName;
  730.     if (bIsShortcut)
  731.         sFullItemName += g_szUrlExt;
  732.  
  733.     return sFullItemName;
  734. }
  735.  
  736. void CFavOrgTreeCtl::UpdateItem(HTREEITEM hItem, BOOL bDeadLinksOnly)
  737. {
  738.     if ((!m_bConnected) && (!m_bDoNotCheck))
  739.         return;
  740.  
  741.     // Get shortcut filename
  742.     CString    sFilename = MakeFullItemName(hItem, TRUE);
  743.  
  744.     // Get URL
  745.     CString sURL;
  746.  
  747.     // Inform user
  748.     CString sShortName;
  749.  
  750.     sShortName = GetItemText(hItem);
  751.     DisplayMsg(IDS_MSG_FAVNAME, sShortName);
  752.  
  753.     if (!GetOrSetURLFromShortcut(sFilename, sURL, TRUE))
  754.         return;
  755.  
  756.     // Check URL
  757.     DWORD                dwServiceType;
  758.     CString                sServer;
  759.     CString                sObject;
  760.     INTERNET_PORT        nPort;
  761.     CHttpConnection*    pHttpConnect = NULL;
  762.     URL_COMPONENTS        UrlComponents;
  763.     int                    nUrlLen;
  764.  
  765.     // This code detects whether the URL contains extra information
  766.     // e.g. an anchor specification. If this information exists, it
  767.     // is removed before checking the URL because SendRequest may
  768.     // fail in that case.
  769.     nUrlLen = sURL.GetLength();
  770.  
  771.     memset(&UrlComponents, 0, sizeof(URL_COMPONENTS));
  772.     UrlComponents.dwStructSize = sizeof(URL_COMPONENTS);
  773.     // The following lines set which components will be displayed.
  774.     UrlComponents.dwExtraInfoLength = 1;
  775.  
  776.     if (!InternetCrackUrl(sURL.GetBuffer(nUrlLen + 1), nUrlLen, 0, &UrlComponents))
  777.         goto exitandprogress;
  778.  
  779.     if ((UrlComponents.dwExtraInfoLength != 0) && (*(UrlComponents.lpszExtraInfo) == '#'))
  780.         // Eliminate extra info for checking
  781.         *(UrlComponents.lpszExtraInfo) = '\0';
  782.  
  783.     sURL.ReleaseBuffer();
  784.  
  785.     if (!AfxParseURL(sURL, dwServiceType, sServer, sObject, nPort))
  786.         goto exitandprogress;
  787.  
  788.      // Check URL and try to find favicon if any
  789.     DisplayMsg(IDS_MSG_CHECKURL, sURL + " (" + GetItemText(hItem) + ")");
  790.  
  791.     if (CheckURL(&pHttpConnect, dwServiceType, sURL, sServer, sObject, nPort, hItem) 
  792.         && ((dwServiceType == AFX_INET_SERVICE_HTTP) || (dwServiceType == AFX_INET_SERVICE_HTTPS))
  793.         && !bDeadLinksOnly
  794.         && (pHttpConnect != NULL))
  795.     {
  796.         // The URL has been successfully checked
  797.         // Retrieve file from web site and store it to icon folder
  798.         CHttpFile* pIconFile = NULL;
  799.  
  800.         try
  801.         {
  802.             pIconFile = pHttpConnect->OpenRequest(CHttpConnection::HTTP_VERB_GET, 
  803.                                                   "/favicon.ico",
  804.                                                   NULL,
  805.                                                   1,
  806.                                                   NULL,
  807.                                                   NULL,
  808.                                                   INTERNET_FLAG_DONT_CACHE 
  809.                                                   | INTERNET_FLAG_EXISTING_CONNECT 
  810.                                                   | (dwServiceType == AFX_INET_SERVICE_HTTPS ? INTERNET_FLAG_SECURE : 0));
  811.  
  812.             if (pIconFile)
  813.             {
  814.                 pIconFile->SetReadBufferSize(2048);
  815.                 pIconFile->SendRequest();
  816.             }
  817.             else 
  818.                 goto exitandprogress;
  819.         }
  820.  
  821.         catch(CInternetException* pEx)
  822.         {
  823.             pEx->Delete();
  824.             if (pIconFile)
  825.             {
  826.                 pIconFile->Close();
  827.                 delete pIconFile;
  828.             }
  829.             goto exitandprogress;
  830.         }
  831.  
  832.         if (!pIconFile)
  833.             goto exitandprogress;
  834.  
  835.         CString    sLocalIconName = m_sIconStore + sServer + ".ico";
  836.         CString sLen;
  837.  
  838.         // Get length of icon file
  839.         pIconFile->QueryInfo(HTTP_QUERY_CONTENT_LENGTH, sLen);
  840.  
  841.         DWORD dwLen = atoi(sLen);
  842.         BYTE* pBuffer;
  843.  
  844.         if ((dwLen <= 0) || (dwLen > 65536)) // Take care of odd values returned from server
  845.             pBuffer = NULL;
  846.         else
  847.             pBuffer = new BYTE[dwLen];
  848.  
  849.         if (pBuffer == NULL)
  850.         {
  851.             pIconFile->Close();
  852.             delete pIconFile;
  853.             goto exitandprogress;
  854.         }
  855.  
  856.         try
  857.         {
  858.             // Get icon data
  859.             pIconFile->Read(pBuffer, dwLen);
  860.             pIconFile->Close();
  861.             delete pIconFile;
  862.             pIconFile = NULL;
  863.  
  864.             // Reject file if not true icon or bitmap
  865.             BOOL bFileOK = IsIconOrBmp(pBuffer, dwLen);
  866.  
  867.             if (bFileOK)
  868.             {
  869.                 CFile fIcon(sLocalIconName, CFile::modeCreate | CFile::modeWrite);
  870.                 fIcon.Write(pBuffer, dwLen);
  871.                 fIcon.Close();
  872.             }
  873.  
  874.             delete pBuffer;
  875.             pBuffer = NULL;
  876.  
  877.             if (!bFileOK)
  878.                 goto exitandprogress;
  879.         }
  880.  
  881.         catch (CInternetException* pEx)
  882.         {
  883.             pEx->Delete();
  884.  
  885.             if (pBuffer)
  886.                 delete pBuffer;
  887.             if (pIconFile)
  888.             {
  889.                 pIconFile->Close();
  890.                 delete pIconFile;
  891.                 pIconFile = NULL;
  892.             }
  893.             goto exitandprogress;
  894.         }
  895.  
  896.         catch (CFileException* pEx)
  897.         {
  898.             pEx->Delete();
  899.  
  900.             if (pBuffer)
  901.                 delete pBuffer;
  902.             if (pIconFile)
  903.                 delete pIconFile;
  904.             goto exitandprogress;
  905.         }
  906.  
  907.         // Verify that we have an icon
  908.         HICON hIconLarge = NULL;
  909.         HICON hIconSmall = NULL;
  910.  
  911.         ExtractIconEx(sLocalIconName, 0, &hIconLarge, &hIconSmall, 1);
  912.  
  913.         if (hIconSmall == NULL)
  914.         {
  915.             hIconSmall = hIconLarge; 
  916.             hIconLarge = NULL;
  917.         }
  918.  
  919.         if (hIconSmall != NULL)
  920.         {
  921.             DisplayMsg(IDS_MSG_ICONFOUND, CString(""));
  922.  
  923.             // Modify shortcut accordingly
  924.             IUniformResourceLocatorPtr pNewUrlLink(CLSID_InternetShortcut, NULL, CLSCTX_INPROC_SERVER);
  925.             IUniformResourceLocatorPtr pUrlLink(CLSID_InternetShortcut, NULL, CLSCTX_INPROC_SERVER);
  926.             if ((pUrlLink != NULL) && (pNewUrlLink != NULL))
  927.             {
  928.                 IPersistFilePtr pNewpf(pNewUrlLink);
  929.                 IPersistFilePtr ppf(pUrlLink);
  930.         
  931.                 if ((ppf != NULL) && (pNewpf != NULL))
  932.                 { 
  933.                     WCHAR wsz[MAX_PATH];
  934.  
  935.                     MultiByteToWideChar(CP_ACP, 0, sFilename, -1, wsz, MAX_PATH);
  936.                     // Load the shortcut. 
  937.                     if (SUCCEEDED(ppf->Load(wsz, STGM_READ)))
  938.                     {
  939.                         IShellLinkPtr psl(pNewUrlLink);
  940.  
  941.                         if (psl != NULL)
  942.                         {
  943.                             LPSTR lpszCurrentURL;
  944.  
  945.                             pUrlLink->GetURL(&lpszCurrentURL);
  946.                             pNewUrlLink->SetURL(lpszCurrentURL, IURL_SETURL_FL_GUESS_PROTOCOL );
  947.                             SetItemIcon(hItem, sLocalIconName, hIconSmall, 0, psl);
  948.                             DeleteFile(sFilename);
  949.                             pNewpf->Save(wsz, TRUE);
  950.                         }
  951.                     }
  952.                 }
  953.             }
  954.  
  955.             DestroyIcon(hIconSmall);
  956.         }
  957.         else
  958.             // Clean up file
  959.             DeleteFile(sLocalIconName);
  960.  
  961.         if (hIconLarge != NULL)
  962.             DestroyIcon(hIconLarge);
  963.     }
  964.  
  965.     if (!m_bCancel)
  966.     {
  967.         Invalidate();
  968.         GetParent()->UpdateWindow();
  969.     }
  970.  
  971. exitandprogress:
  972.  
  973.     if (pHttpConnect)
  974.     {
  975.         pHttpConnect->Close();
  976.         delete pHttpConnect;
  977.     }
  978.  
  979.     if (m_pProgressCtl)
  980.         m_pProgressCtl->OffsetPos(1);
  981. }
  982.  
  983. void CFavOrgTreeCtl::ProcessItem(HTREEITEM hItem, BOOL bDeadLinksOnly)
  984. {
  985.     if (GetItemData(hItem) == ITEM_IS_FOLDER)
  986.     {
  987.         // It's a folder (we have a selection of folders)
  988.         // Process all items in this folder
  989.         HTREEITEM hChildItem = GetChildItem(hItem);
  990.  
  991.         while (!m_bCancel && (hChildItem != NULL))
  992.         {
  993.             if (GetItemData(hChildItem) == ITEM_IS_FOLDER)
  994.                 ProcessItem(hChildItem, bDeadLinksOnly);
  995.             else
  996.                 UpdateItem(hChildItem, bDeadLinksOnly);
  997.             hChildItem = GetNextItem(hChildItem, TVGN_NEXT);
  998.         }
  999.     }
  1000.     else
  1001.         UpdateItem(hItem, bDeadLinksOnly);
  1002. }
  1003.  
  1004. void CFavOrgTreeCtl::ProcessItems(BOOL bDeadLinksOnly)
  1005. {
  1006.     // Connect if necessary
  1007.     if (!GetConnectState())
  1008.         return;
  1009.  
  1010.     HTREEITEM    hCurItem;
  1011.  
  1012.     m_bCancel = FALSE;
  1013.     m_bProcessing = TRUE;
  1014.     m_bLetUserScroll = FALSE;
  1015.  
  1016.     if (m_pProgressCtl)
  1017.     {
  1018.         m_pProgressCtl->SetStep(1);
  1019.         m_pProgressCtl->SetPos(0);
  1020.     }
  1021.  
  1022.     if (!m_SelItemList.IsEmpty())
  1023.     {
  1024.         // We have a selection
  1025.         if (m_pProgressCtl)
  1026.             m_pProgressCtl->SetRange32(0, CountSelected());
  1027.  
  1028.         POSITION pos = m_SelItemList.GetHeadPosition();
  1029.  
  1030.         // Enumerate selection
  1031.         while (!m_bCancel && (pos != NULL))
  1032.         {
  1033.             hCurItem = m_SelItemList.GetNext(pos);
  1034.             ProcessItem(hCurItem, bDeadLinksOnly);
  1035.         }
  1036.     }
  1037.     else
  1038.     {
  1039.         // Enumerate tree
  1040.         if (m_pProgressCtl)
  1041.             m_pProgressCtl->SetRange32(0, m_nLoadedItems);
  1042.  
  1043.         hCurItem = GetChildItem(m_hRootItem);
  1044.         while (!m_bCancel && (hCurItem != NULL))
  1045.         {
  1046.             ProcessItem(hCurItem, bDeadLinksOnly);
  1047.             hCurItem = GetNextItem(hCurItem, TVGN_NEXT);
  1048.         }
  1049.     }
  1050. }
  1051.  
  1052. void CFavOrgTreeCtl::CheckAndFindIcons(BOOL bDeadLinksOnly)
  1053. {
  1054.     //Start worker thread
  1055.     CWinThread* pWorkThread = AfxBeginThread(DoProcessItems, (LPVOID) &bDeadLinksOnly);
  1056.     pWorkThread->m_bAutoDelete = FALSE;
  1057.  
  1058.     BOOL    bQuitLoop = FALSE;
  1059.  
  1060.     while (!bQuitLoop)
  1061.     {
  1062.         // Wait for thread to terminate or
  1063.         // for a message in input queue
  1064.         if (MsgWaitForMultipleObjects(1, 
  1065.                                       &(pWorkThread->m_hThread), 
  1066.                                       FALSE, 
  1067.                                       INFINITE, 
  1068.                                       QS_ALLINPUT) == WAIT_OBJECT_0)
  1069.             bQuitLoop = TRUE;
  1070.         else
  1071.             PeekAndYield();
  1072.     }
  1073.  
  1074.     delete pWorkThread;
  1075.  
  1076.     // Notify parent so that the user interface can be re-enabled
  1077.     GetParent()->PostMessage(WM_CAN_UNLOCK, 0, 0);
  1078.  
  1079.     if (m_pProgressCtl)
  1080.         m_pProgressCtl->SetPos(0);
  1081.     ClearMsg();
  1082.  
  1083.     SetCursor(LoadCursor(NULL, IDC_ARROW));
  1084.     m_bProcessing = FALSE;
  1085.     m_bCancel = FALSE;
  1086.  
  1087.     Invalidate();
  1088.     GetParent()->UpdateWindow();
  1089. }
  1090.  
  1091. void CFavOrgTreeCtl::ProcessDeadLink(HTREEITEM hItem)
  1092. {
  1093.     int nState = GetItemState(hItem, TVIS_STATEIMAGEMASK) & ~0xFF;
  1094.  
  1095.     if (nState == INDEXTOSTATEIMAGEMASK(STATE_INDEX_PAGENONE))
  1096.     {
  1097.         // Reset shortcut to root URL
  1098.         CString sName = MakeFullItemName(hItem, TRUE);
  1099.         CString sURL;
  1100.  
  1101.         if (GetOrSetURLFromShortcut(sName, sURL, TRUE))
  1102.         {
  1103.             DWORD            dwServiceType;
  1104.             CString            sServer;
  1105.             CString            sObject;
  1106.             INTERNET_PORT    nPort;
  1107.  
  1108.             // Parse URL
  1109.             if (!AfxParseURL(sURL, dwServiceType, sServer, sObject, nPort))
  1110.                 goto exitandprogress;
  1111.  
  1112.             CStringEx sNewURL;
  1113.  
  1114.             // Compute favicon filename
  1115.             if (dwServiceType = AFX_INET_SERVICE_HTTP)
  1116.                 sNewURL = "http://";
  1117.             else if (dwServiceType = AFX_INET_SERVICE_HTTPS)
  1118.                 sNewURL = "https://";
  1119.             else
  1120.                 goto exitandprogress;
  1121.  
  1122.             sNewURL += sServer;
  1123.  
  1124.             if (nPort != 80)
  1125.             {
  1126.                 CString sPort;
  1127.  
  1128.                 sPort.Format("%d", nPort);
  1129.                 sPort = CString(":") + sPort;
  1130.                 sNewURL += sPort;
  1131.             }
  1132.  
  1133.             DisplayMsg(IDS_MSG_UPDATINGDEADLINK, sNewURL);
  1134.             // Set new URL
  1135.             GetOrSetURLFromShortcut(sName, sNewURL, FALSE);
  1136.             if (!m_bLetUserScroll)
  1137.                 EnsureVisible(hItem);
  1138.             // Check URL again
  1139.             ProcessItem(hItem, TRUE);
  1140.             // Change state accordingly
  1141.             SetItemState(hItem, INDEXTOSTATEIMAGEMASK(STATE_INDEX_RESET), TVIS_STATEIMAGEMASK);
  1142.         }
  1143.     }
  1144.  
  1145.     PeekAndYield();
  1146.  
  1147. exitandprogress:
  1148.     if (m_pProgressCtl)
  1149.         m_pProgressCtl->OffsetPos(1);
  1150. }
  1151.  
  1152. void CFavOrgTreeCtl::ProcessDeadLinks(HTREEITEM hItem)
  1153. {
  1154.     if (GetItemData(hItem) == ITEM_IS_FOLDER)
  1155.     {
  1156.         // It's a folder
  1157.         // Process all items in this folder
  1158.         HTREEITEM hChildItem = GetChildItem(hItem);
  1159.  
  1160.         while (!m_bCancel && (hChildItem != NULL))
  1161.         {
  1162.             if (GetItemData(hChildItem) == ITEM_IS_FOLDER)
  1163.                 ProcessDeadLinks(hChildItem);
  1164.             else
  1165.                 ProcessDeadLink(hChildItem);
  1166.             hChildItem = GetNextItem(hChildItem, TVGN_NEXT);
  1167.         }
  1168.  
  1169.         if (m_bCancel)
  1170.             GetParent()->PostMessage(WM_CAN_UNLOCK, 0, 0);
  1171.     }
  1172.     else
  1173.         ProcessDeadLink(hItem);
  1174. }
  1175.  
  1176. void CFavOrgTreeCtl::ResetDeadLinks()
  1177. {
  1178.     m_bProcessing = TRUE;
  1179.     m_bLetUserScroll = FALSE;
  1180.  
  1181.     if (m_pProgressCtl)
  1182.     {
  1183.         m_pProgressCtl->SetRange32(0, m_nLoadedItems);
  1184.         m_pProgressCtl->SetStep(1);
  1185.         m_pProgressCtl->SetPos(0);
  1186.     }
  1187.  
  1188.     m_bCancel = FALSE;
  1189.  
  1190.     ClearSelection(TRUE);
  1191.     // Find all items marked as dead links
  1192.     ProcessDeadLinks(m_hRootItem);
  1193.  
  1194.     m_bCancel = FALSE;
  1195.     if (m_pProgressCtl)
  1196.         m_pProgressCtl->SetPos(0);
  1197.     ClearMsg();
  1198.  
  1199.     SetCursor(LoadCursor(NULL, IDC_ARROW));
  1200.     m_bProcessing = FALSE;
  1201. }
  1202.  
  1203. void CFavOrgTreeCtl::CancelAction()
  1204. {
  1205.     m_bCancel = TRUE;
  1206. }
  1207.  
  1208. void CFavOrgTreeCtl::ClearSelection(BOOL bCleanTree)
  1209. {
  1210.     if (!m_bProcessing)
  1211.         CMultiselTreeCtrl::ClearSelection(bCleanTree);
  1212. }
  1213.  
  1214. BOOL CFavOrgTreeCtl::CheckURL(CHttpConnection** ppHttpConnect, DWORD dwServiceType, CStringEx sUrl, CStringEx sServer, CStringEx sObject, int nPort, HTREEITEM hItem)
  1215. {
  1216.     CHttpConnection*    pHttpConnect = NULL;
  1217.     CFtpConnection*        pFtpConnect = NULL;
  1218.     DWORD                dwCurData;
  1219.     CHttpFile*            pFile = NULL;
  1220.     DWORD                dwStatusCode;
  1221.     int                    nStateIndex;
  1222.     BOOL                bOK = TRUE;
  1223.     CString*            psItemInfo;
  1224.  
  1225.     if (m_pInet == NULL)
  1226.         return FALSE;
  1227.  
  1228.     int nTimeout = m_nTimeout * 1000;
  1229.  
  1230.     if (dwServiceType == AFX_INET_SERVICE_FILE)
  1231.     // URL is something like file:///c:/xxxxx/xxxx.xxx
  1232.     {
  1233.         HANDLE    hFile;
  1234.  
  1235.         sObject = sObject.URLDecode();
  1236.  
  1237.         if ((hFile = CreateFile(sObject, GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, NULL)) == INVALID_HANDLE_VALUE)
  1238.         {
  1239.             DisplayMsg(IDS_MSG_NOTFOUND, sObject);
  1240.             nStateIndex = STATE_INDEX_PAGENONE;
  1241.             bOK = FALSE;
  1242.         }
  1243.         else
  1244.         {
  1245.             CloseHandle(hFile);
  1246.             DisplayMsg(IDS_MSG_OK, sUrl + " (" + GetItemText(hItem) + ")");
  1247.             nStateIndex = STATE_INDEX_CHECKED;
  1248.         }
  1249.  
  1250.         goto AssignImage;
  1251.     }
  1252.  
  1253.     try
  1254.     {
  1255.         if ((dwServiceType == AFX_INET_SERVICE_HTTP) || (dwServiceType == AFX_INET_SERVICE_HTTPS))
  1256.         {
  1257.             // It's an HTTP URL - try to connect
  1258.             pHttpConnect = m_pInet->GetHttpConnection(sServer, (INTERNET_PORT) (nPort != 80 ? nPort : INTERNET_INVALID_PORT_NUMBER));
  1259.             if (pHttpConnect)
  1260.             {
  1261.                 // OK - Now try to GET object
  1262.                 // We should actually use the HEAD request to reduce traffic but :
  1263.                 // 1. Many servers DO NOT support the HEAD request
  1264.                 // 2. Using GET doesn't cause too much data to be sent over the network
  1265.                 //    since we are only requesting the header.
  1266.                 pFile = pHttpConnect->OpenRequest(CHttpConnection::HTTP_VERB_GET, 
  1267.                                                   sObject,
  1268.                                                   NULL,
  1269.                                                   1,
  1270.                                                   NULL,
  1271.                                                   NULL,
  1272.                                                   INTERNET_FLAG_DONT_CACHE 
  1273.                                                   | INTERNET_FLAG_NO_AUTO_REDIRECT
  1274.                                                   | (dwServiceType == AFX_INET_SERVICE_HTTPS ? INTERNET_FLAG_SECURE : 0));
  1275.  
  1276.                 // We do not allow auto-redirection in order to be notified of redirected pages
  1277.                 if (pFile)
  1278.                 {
  1279.                     pFile->SetReadBufferSize(512);
  1280. resend:
  1281.                     pFile->SendRequest();
  1282.                     pFile->QueryInfoStatusCode(dwStatusCode);
  1283.                 }
  1284.             }
  1285.             else
  1286.                 return FALSE;
  1287.         }
  1288.         else if (dwServiceType == AFX_INET_SERVICE_FTP)
  1289.         {
  1290.             // It's an FTP URL - try to connect
  1291.             try
  1292.             {
  1293.                 if (pFtpConnect = m_pInet->GetFtpConnection(sServer))
  1294.                 {
  1295.                     // OK - We don't try to download the file
  1296.                     DisplayMsg(IDS_MSG_OK, sUrl + " (" + GetItemText(hItem) + ")");
  1297.                     nStateIndex = STATE_INDEX_CHECKED;
  1298.                     pFtpConnect->Close();
  1299.                     delete pFtpConnect;
  1300.                     pFtpConnect = NULL;
  1301.                     goto AssignImage;
  1302.                 }
  1303.                 else
  1304.                 {
  1305.                     // No connection - bad link
  1306.                     DisplayMsg(IDS_MSG_NOSITE, sServer);
  1307.                     nStateIndex = STATE_INDEX_SITENONE;
  1308.                     bOK = FALSE;
  1309.                     goto AssignImage;
  1310.                 }
  1311.             }
  1312.  
  1313.             catch(CInternetException* pEx)
  1314.             {
  1315.                 DWORD dwError = pEx->m_dwError;
  1316.                 pEx->Delete();
  1317.                 if (pFtpConnect)
  1318.                 {
  1319.                     pFtpConnect->Close();
  1320.                     delete pFtpConnect;
  1321.                     pFtpConnect = NULL;
  1322.                 }
  1323.                 DisplayMsg(IDS_MSG_NOSITE, sServer);
  1324.                 nStateIndex = STATE_INDEX_SITENONE;
  1325.                 bOK = FALSE;
  1326.                 goto AssignImage;
  1327.             }
  1328.         }
  1329.         else 
  1330.         {
  1331.             DisplayMsg(IDS_MSG_UNKNOWN, sServer);
  1332.             nStateIndex = STATE_INDEX_QUESTION;
  1333.             bOK = FALSE;
  1334.             goto AssignImage;
  1335.         }
  1336.     }
  1337.  
  1338.     catch(CInternetException* pEx)
  1339.     {
  1340.         // Handle main internet exceptions
  1341.         DWORD dwError = pEx->m_dwError;
  1342.         pEx->Delete();
  1343.  
  1344.         switch(dwError)
  1345.         {
  1346.             case ERROR_INTERNET_INCORRECT_USER_NAME:
  1347.             case ERROR_INTERNET_INCORRECT_PASSWORD:
  1348.             case ERROR_INTERNET_LOGIN_FAILURE:
  1349.             case ERROR_INTERNET_CLIENT_AUTH_CERT_NEEDED:
  1350.             case ERROR_INTERNET_CLIENT_AUTH_NOT_SETUP:
  1351.                 DisplayMsg(IDS_MSG_ACCESSDENIED, CString(""));
  1352.                 nStateIndex = STATE_INDEX_ACCESSDENIED;
  1353.                 bOK = FALSE;
  1354.                 break;
  1355.  
  1356.             case ERROR_INTERNET_TIMEOUT:
  1357.                 DisplayMsg(IDS_MSG_TIMEOUT, CString(""));
  1358.                 nStateIndex = STATE_INDEX_TIMEOUT;
  1359.                 bOK = FALSE;
  1360.                 break;
  1361.  
  1362.             case ERROR_INTERNET_EXTENDED_ERROR:
  1363.             case ERROR_INTERNET_INVALID_URL:
  1364.             case ERROR_INTERNET_NAME_NOT_RESOLVED:
  1365.             case ERROR_INTERNET_ITEM_NOT_FOUND:
  1366.             case ERROR_INTERNET_CANNOT_CONNECT:
  1367.             case ERROR_INTERNET_SERVER_UNREACHABLE:
  1368.             case ERROR_INTERNET_PROXY_SERVER_UNREACHABLE:
  1369.             case ERROR_INTERNET_DISCONNECTED:
  1370.                 DisplayMsg(IDS_MSG_NOSITE, sServer);
  1371.                 nStateIndex = STATE_INDEX_SITENONE;
  1372.                 bOK = FALSE;
  1373.                 break;
  1374.  
  1375.             default:
  1376.                 DisplayMsg(IDS_MSG_UNKNOWN, sServer);
  1377.                 nStateIndex = STATE_INDEX_QUESTION;
  1378.                 bOK = FALSE;
  1379.                 break;
  1380.         }
  1381.  
  1382.         goto AssignImage;
  1383.     }
  1384.  
  1385.     psItemInfo = new CString;
  1386.  
  1387.     if (!psItemInfo)
  1388.     {
  1389.         DisplayMsg(IDS_MSG_UNKNOWN, sServer);
  1390.         nStateIndex = STATE_INDEX_QUESTION;
  1391.         bOK = FALSE;
  1392.         goto AssignImage;
  1393.     }
  1394.  
  1395.     // Get response header and status code
  1396.     pFile->QueryInfo(HTTP_QUERY_RAW_HEADERS_CRLF, *psItemInfo);
  1397.  
  1398.     // Replace item info
  1399.     dwCurData = GetItemData(hItem);
  1400.     if ((dwCurData != ITEM_IS_FOLDER) && (dwCurData != 0))
  1401.         delete (CString*) dwCurData;
  1402.     SetItemData(hItem, (DWORD) psItemInfo);
  1403.  
  1404.     switch(dwStatusCode)
  1405.     {
  1406.         case HTTP_STATUS_OK:
  1407.             DisplayMsg(IDS_MSG_OK, sUrl + " (" + GetItemText(hItem) + ")");
  1408.             nStateIndex = STATE_INDEX_CHECKED;
  1409.             break;
  1410.  
  1411.         case HTTP_STATUS_MOVED:
  1412.         case HTTP_STATUS_REDIRECT:
  1413.             if (psItemInfo && m_bCanRedirect && (dwStatusCode != HTTP_STATUS_REDIRECT))
  1414.             // If allowed by the user, try to reset the shortcut to the new location.
  1415.             // We do not update the shortcut in case of a temporary redirection.
  1416.             {
  1417.                 CStringEx sNewLocation = *psItemInfo;
  1418.  
  1419.                 int nPos = sNewLocation.Find(g_szLocation);
  1420.                 if (nPos == -1)
  1421.                     goto pagemoved;
  1422.                 sNewLocation = sNewLocation.Mid(nPos + strlen(g_szLocation));
  1423.                 nPos = sNewLocation.Find(('\r'));
  1424.                 if (nPos > 0)
  1425.                 {
  1426.                     sNewLocation = sNewLocation.Left(nPos);
  1427.                     sNewLocation.Trim();
  1428.  
  1429.                     if (sNewLocation.Left(4).CompareNoCase("http") != 0)
  1430.                     {
  1431.                         // We have to reconstruct the URL
  1432.                         CString sURL;
  1433.  
  1434.                         sURL = "http://" + sServer + sNewLocation;
  1435.                         if (nPort != 80)
  1436.                         {
  1437.                             CString sPort;
  1438.  
  1439.                             sPort.Format("%d", nPort);
  1440.                             sPort = CString(":") + sPort;
  1441.                             sURL += sPort;
  1442.                         }
  1443.  
  1444.                         sNewLocation = sURL;
  1445.                     }
  1446.  
  1447.                     // Set shortcut to new location
  1448.                     if (GetOrSetURLFromShortcut(MakeFullItemName(hItem, TRUE), sNewLocation, FALSE))
  1449.                     {
  1450.                         DisplayMsg(IDS_MSG_REDIRWITHUPDATE, CString(""));
  1451.                         nStateIndex = STATE_INDEX_MOVED_UPDATED;
  1452.                     }
  1453.                     else
  1454.                         goto pagemoved;
  1455.                 }    
  1456.                 else
  1457.                     goto pagemoved;
  1458.             }
  1459.             else
  1460.             {
  1461. pagemoved:
  1462.                 DisplayMsg(IDS_MSG_REDIR, CString(""));
  1463.                 nStateIndex = STATE_INDEX_MOVED;
  1464.             }
  1465.             break;
  1466.  
  1467.         case HTTP_STATUS_NOT_FOUND:
  1468.         case HTTP_STATUS_GONE:
  1469.             DisplayMsg(IDS_MSG_NOTFOUND, sObject);
  1470.             nStateIndex = STATE_INDEX_PAGENONE;
  1471.             break;
  1472.  
  1473.         case HTTP_STATUS_PROXY_AUTH_REQ:
  1474.             {
  1475.                 DWORD dwPrompt = pFile->ErrorDlg();
  1476.  
  1477.                 if (dwPrompt == ERROR_INTERNET_FORCE_RETRY)
  1478.                 {
  1479.                     goto resend;
  1480.                     break;
  1481.                 }
  1482.                 // else fall through
  1483.             }
  1484.  
  1485.         case HTTP_STATUS_DENIED:
  1486.         case HTTP_STATUS_FORBIDDEN:
  1487.             DisplayMsg(IDS_MSG_ACCESSDENIED, CString(""));
  1488.             nStateIndex = STATE_INDEX_ACCESSDENIED;
  1489.             break;
  1490.  
  1491.         case HTTP_STATUS_GATEWAY_TIMEOUT:
  1492.         case HTTP_STATUS_REQUEST_TIMEOUT:
  1493.             DisplayMsg(IDS_MSG_TIMEOUT, CString(""));
  1494.             nStateIndex = STATE_INDEX_TIMEOUT;
  1495.             break;
  1496.  
  1497.         case HTTP_STATUS_BAD_METHOD:
  1498.         case HTTP_STATUS_NOT_SUPPORTED:
  1499.         default:
  1500.             DisplayMsg(IDS_MSG_UNKNOWN, sServer);
  1501.             nStateIndex = STATE_INDEX_QUESTION;
  1502.             break;
  1503.     }
  1504.  
  1505. AssignImage:
  1506.  
  1507.     if (pFile)
  1508.     {
  1509.         pFile->Close();
  1510.         delete pFile;
  1511.     }
  1512.  
  1513.     // Pass back http connection to caller so that it can 
  1514.     // retrieve the favicon from the same connection
  1515.     if (bOK)
  1516.         *ppHttpConnect = pHttpConnect;
  1517.     else if (pHttpConnect != NULL)
  1518.     {
  1519.         pHttpConnect->Close();
  1520.         delete pHttpConnect;
  1521.         *ppHttpConnect = NULL;
  1522.     }
  1523.  
  1524.     if (pFtpConnect)
  1525.     {
  1526.         pFtpConnect->Close();
  1527.         delete pFtpConnect;
  1528.     }
  1529.  
  1530.     // Display new status icon    
  1531.     SetItemState(hItem, INDEXTOSTATEIMAGEMASK(nStateIndex), TVIS_STATEIMAGEMASK);
  1532.     if (!m_bLetUserScroll)
  1533.         EnsureVisible(hItem);
  1534.  
  1535.     return bOK;
  1536. }
  1537.  
  1538. void CFavOrgTreeCtl::SetItemIcon(HTREEITEM hItem, CString sIconName, HICON hIcon, int nIndex, IShellLinkPtr psl)
  1539. {
  1540.     // Set icon location in shortcut
  1541.     if ((psl != NULL) && SUCCEEDED(psl->SetIconLocation(sIconName, nIndex)))
  1542.     {
  1543.         int nImage, nSelectedImage;
  1544.  
  1545.         GetItemImage(hItem, nImage, nSelectedImage);
  1546.         if (nImage != m_nStdIconNotSel)
  1547.         // Item already has a custom icon
  1548.         {
  1549.             m_imgStd.Replace(nImage, hIcon);
  1550.             if (nImage != nSelectedImage)
  1551.                 m_imgStd.Replace(nSelectedImage, hIcon);
  1552.         }
  1553.         else
  1554.         // It's a new icon - do not replace the common standard icon
  1555.         {
  1556.             int nNewIndex = m_imgStd.Add(hIcon);
  1557.             SetItemImage(hItem, nNewIndex, nNewIndex);
  1558.         }
  1559.     }
  1560. }
  1561.  
  1562. BOOL CFavOrgTreeCtl::GetOrSetURLFromShortcut(CString sFilename, CString& sURL, BOOL bGet)
  1563. {
  1564.     // Get URL from shortcut
  1565.     HRESULT        hr;
  1566.     IMalloc*    pMalloc;
  1567.  
  1568.     if (bGet)
  1569.     {
  1570.         hr = SHGetMalloc(&pMalloc);
  1571.         if (!SUCCEEDED(hr))
  1572.             return FALSE;
  1573.     }
  1574.  
  1575.     IUniformResourceLocatorPtr pUrlLink(CLSID_InternetShortcut, NULL, CLSCTX_INPROC_SERVER);
  1576.     if (pUrlLink != NULL)
  1577.     {
  1578.         // Get a pointer to the IPersistFile interface. 
  1579.         IPersistFilePtr ppf(pUrlLink);  
  1580.         
  1581.         if (ppf != NULL)
  1582.         { 
  1583.             WCHAR wsz[MAX_PATH];
  1584.             MultiByteToWideChar(CP_ACP, 0, sFilename, -1, wsz, MAX_PATH);
  1585.             // Load the shortcut. 
  1586.             if (SUCCEEDED(ppf->Load(wsz, STGM_READ)))
  1587.             {
  1588.                 if (bGet)
  1589.                 {
  1590.                     LPTSTR  lpszURL = NULL;
  1591.                     // Get URL
  1592.                     hr = pUrlLink->GetURL(&lpszURL);
  1593.                     if (SUCCEEDED(hr) && lpszURL)
  1594.                     {
  1595.                         sURL = lpszURL;
  1596.                         pMalloc->Free(lpszURL);
  1597.                     }
  1598.                     else
  1599.                     {
  1600.                         pMalloc->Release();
  1601.                         return FALSE;
  1602.                     }
  1603.                 }
  1604.                 else
  1605.                 {
  1606.                     // Set URL
  1607.                     BOOL bOK = SUCCEEDED(pUrlLink->SetURL(sURL, 0));
  1608.                     bOK = bOK && SUCCEEDED(ppf->Save(NULL, FALSE));
  1609.  
  1610.                     return bOK;
  1611.                 }
  1612.             }
  1613.         } 
  1614.     }
  1615.     else if (bGet)
  1616.     {
  1617.         pMalloc->Release();
  1618.         return FALSE;
  1619.     }
  1620.  
  1621.     if (bGet)
  1622.         pMalloc->Release();
  1623.  
  1624.     return TRUE;
  1625. }
  1626.  
  1627. void CFavOrgTreeCtl::OnLButtonDown(UINT nFlags, CPoint point) 
  1628. {
  1629.     UINT flags;
  1630.  
  1631.     // Helper to fix tree control bug
  1632.     if (m_SelItemList.IsEmpty())
  1633.         SelectItem(NULL);
  1634.  
  1635.     HitTest(point, &flags);
  1636.  
  1637.     if (TVHT_ONITEM & flags)
  1638.     {
  1639.         if (!m_bProcessing)
  1640.             CMultiselTreeCtrl::OnLButtonDown(nFlags, point);
  1641.     }
  1642.     else
  1643.         CMultiselTreeCtrl::OnLButtonDown(nFlags, point);
  1644.  
  1645.     // Helper to fix tree control bug
  1646.     if (m_SelItemList.IsEmpty())
  1647.         SelectItem(NULL);
  1648.     // Helper to fix problem with CMultiselTreeCtrl
  1649.     else if (m_SelItemList.GetCount() == 1)
  1650.     {
  1651.         long lResult;
  1652.  
  1653.         OnSelChanged(NULL, &lResult);
  1654.     }
  1655. }
  1656.  
  1657. void CFavOrgTreeCtl::OnLButtonDblClk(UINT nFlags, CPoint point) 
  1658. {
  1659.     if (!m_bProcessing)
  1660.     {
  1661.         UINT flags;
  1662.         HTREEITEM hItem = HitTest(point, &flags);
  1663.  
  1664.         if (hItem == NULL)
  1665.         {
  1666.             ClearSelection(TRUE);
  1667.             return;
  1668.         }
  1669.  
  1670.         if ((flags & TVHT_ONITEM) && (GetItemData(hItem) != ITEM_IS_FOLDER))
  1671.         {
  1672.             CString sURL;
  1673.  
  1674.             // Get URL and execute
  1675.             GetOrSetURLFromShortcut(MakeFullItemName(hItem , TRUE), sURL, TRUE);
  1676.             ShellExecute(m_hWnd, "open", sURL, NULL, NULL, SW_SHOW);
  1677.         }
  1678.         
  1679.         CMultiselTreeCtrl::OnLButtonDblClk(nFlags, point);
  1680.     }
  1681.  
  1682.     // Helper to fix tree control bug
  1683.     if (m_SelItemList.IsEmpty())
  1684.         SelectItem(NULL);
  1685. }
  1686.  
  1687. void CFavOrgTreeCtl::GetItemCommonStatus(HTREEITEM hItem, BOOL& bOK, int& nFirstStatus)
  1688. {
  1689.     int nStatus;
  1690.  
  1691.     if (GetItemData(hItem) == ITEM_IS_FOLDER)
  1692.     {
  1693.         HTREEITEM hChildItem = GetChildItem(hItem);
  1694.  
  1695.         while (bOK && (hChildItem != NULL))
  1696.         {
  1697.             if (GetItemData(hChildItem) == ITEM_IS_FOLDER)
  1698.                 GetItemCommonStatus(hChildItem, bOK, nFirstStatus);
  1699.             else
  1700.             {
  1701.                 nStatus = GetItemState(hChildItem, TVIS_STATEIMAGEMASK) & ~0xFF;
  1702.                 if (nFirstStatus == -1)
  1703.                     nFirstStatus = nStatus;
  1704.                 else
  1705.                     bOK = bOK && (nFirstStatus == nStatus);
  1706.             }
  1707.  
  1708.             hChildItem = GetNextItem(hChildItem, TVGN_NEXT);
  1709.         }
  1710.     }
  1711.     else
  1712.     {
  1713.         nStatus = GetItemState(hItem, TVIS_STATEIMAGEMASK) & ~0xFF;
  1714.         if (nFirstStatus == -1)
  1715.             nFirstStatus = nStatus;
  1716.         else
  1717.             bOK = bOK && (nFirstStatus == nStatus);
  1718.     }
  1719. }
  1720.  
  1721. void CFavOrgTreeCtl::GetFoldersCommonStatus(HTREEITEM hItem, BOOL& bOK, int& nFirstStatus)
  1722. {
  1723.     HTREEITEM    hCurItem;
  1724.  
  1725.     if (hItem == NULL)
  1726.     {
  1727.         // We want the selection if any
  1728.         POSITION pos = m_SelItemList.GetHeadPosition();
  1729.  
  1730.         while (bOK && (pos != NULL))
  1731.         {
  1732.             hCurItem = m_SelItemList.GetNext(pos);
  1733.             GetItemCommonStatus(hCurItem, bOK, nFirstStatus);
  1734.         }
  1735.     }
  1736.     else
  1737.         GetItemCommonStatus(hItem, bOK, nFirstStatus);
  1738. }
  1739.  
  1740. int CFavOrgTreeCtl::GetCommonStatus(HTREEITEM hItem)
  1741. {
  1742.     int        nFirstStatus = -1;
  1743.     BOOL    bOK = TRUE;
  1744.  
  1745.     GetFoldersCommonStatus(hItem, bOK, nFirstStatus);
  1746.  
  1747.     return bOK ? nFirstStatus : -1;
  1748. }
  1749.  
  1750. int CFavOrgTreeCtl::GetMenuToCheckFromState(int nState)
  1751. {
  1752.     int nMenuToCheck = -1;
  1753.  
  1754.     switch(nState)
  1755.     {
  1756.         case INDEXTOSTATEIMAGEMASK(STATE_INDEX_QUESTION):
  1757.             nMenuToCheck = IDC_MNU_QUESTION; 
  1758.             break;
  1759.         case INDEXTOSTATEIMAGEMASK(STATE_INDEX_CHECKED):
  1760.             nMenuToCheck = IDC_MNU_CHECKED;
  1761.             break;
  1762.         case INDEXTOSTATEIMAGEMASK(STATE_INDEX_PAGENONE):
  1763.             nMenuToCheck = IDC_MNU_PAGENONE;
  1764.             break;
  1765.         case INDEXTOSTATEIMAGEMASK(STATE_INDEX_MOVED):
  1766.             nMenuToCheck = IDC_MNU_MOVED;
  1767.             break;
  1768.         case INDEXTOSTATEIMAGEMASK(STATE_INDEX_TIMEOUT):
  1769.             nMenuToCheck = IDC_MNU_TIMEOUT;
  1770.             break;
  1771.         case INDEXTOSTATEIMAGEMASK(STATE_INDEX_SITENONE):
  1772.             nMenuToCheck = IDC_MNU_SITENONE;
  1773.             break;
  1774.         case INDEXTOSTATEIMAGEMASK(STATE_INDEX_ACCESSDENIED):
  1775.             nMenuToCheck = IDC_MNU_ACCESSDENIED;
  1776.             break;
  1777.         case INDEXTOSTATEIMAGEMASK(STATE_INDEX_MOVED_UPDATED):
  1778.             nMenuToCheck = IDC_MNU_MOVED_UPDATED;
  1779.             break;
  1780.         case INDEXTOSTATEIMAGEMASK(STATE_INDEX_UNCHECKED):
  1781.             nMenuToCheck = IDC_MNU_UNCHECKED;
  1782.             break;
  1783.     }
  1784.  
  1785.     return nMenuToCheck;
  1786. }
  1787.  
  1788. void CFavOrgTreeCtl::OnRButtonDown(UINT nFlags, CPoint point) 
  1789. {
  1790.     if (!m_bProcessing)    
  1791.     {
  1792.         UINT flags;
  1793.         HTREEITEM hItem = HitTest(point, &flags);
  1794.         CMenu    mnuMain;
  1795.         CMenu*    pmnuCtxt;
  1796.  
  1797.         ClientToScreen(&point);
  1798.  
  1799.         if (hItem != NULL)
  1800.         {
  1801.             BOOL bIsFolder = GetItemData(hItem) == ITEM_IS_FOLDER;
  1802.  
  1803.             // The user right-clicked a shortcut 
  1804.             mnuMain.LoadMenu(IDR_MAINFRAME);
  1805.             pmnuCtxt = mnuMain.GetSubMenu(1);
  1806.  
  1807.             int        nMenuToCheck = -1;
  1808.             int        nState;
  1809.             BOOL    bInSelection;
  1810.  
  1811.             bInSelection = ((GetItemState(hItem, TVIS_SELECTED) & TVIS_SELECTED) != 0)
  1812.                              &&
  1813.                             (m_SelItemList.GetCount() > 1);
  1814.  
  1815.             if (!bInSelection && !bIsFolder)
  1816.                 nState = GetItemState(hItem, TVIS_STATEIMAGEMASK) & ~0xFF;
  1817.             else if(!bInSelection)
  1818.                 nState = GetCommonStatus(hItem);
  1819.             else
  1820.                 nState = GetCommonStatus(NULL);
  1821.  
  1822.             if (nState != -1)
  1823.                 // Get the menu item corresponding to the item(s) state
  1824.                 nMenuToCheck = GetMenuToCheckFromState(nState);
  1825.             if (nMenuToCheck != -1)
  1826.                     pmnuCtxt->CheckMenuItem(nMenuToCheck, MF_CHECKED | MF_BYCOMMAND);
  1827.  
  1828.             m_hLastCtxtItem = hItem;
  1829.             if (bInSelection)
  1830.                 // Click in a selection - change the whole selection
  1831.                 m_hLastCtxtItem = NULL;
  1832.             else
  1833.                 SetItemState(hItem, TVIS_BOLD, TVIS_BOLD );
  1834.  
  1835.             if (m_hLastCtxtItem)
  1836.             {
  1837.                 pmnuCtxt->EnableMenuItem(IDC_DISPINFO, 
  1838.                                          MF_BYCOMMAND | (bIsFolder || (GetItemData(hItem) == 0) ? MF_DISABLED | MF_GRAYED : MF_ENABLED));
  1839.                 pmnuCtxt->EnableMenuItem(IDC_EDITURL, 
  1840.                                          MF_BYCOMMAND | (bIsFolder ? MF_DISABLED | MF_GRAYED : MF_ENABLED));
  1841.                 pmnuCtxt->EnableMenuItem(IDC_PICKICON, 
  1842.                                          MF_BYCOMMAND | (bIsFolder ? MF_DISABLED | MF_GRAYED : MF_ENABLED));
  1843.             }
  1844.             else
  1845.             {
  1846.                 pmnuCtxt->EnableMenuItem(IDC_DISPINFO, MF_BYCOMMAND | MF_DISABLED | MF_GRAYED);
  1847.                 pmnuCtxt->EnableMenuItem(IDC_EDITURL, MF_BYCOMMAND | MF_DISABLED | MF_GRAYED);
  1848.                 pmnuCtxt->EnableMenuItem(IDC_PICKICON, MF_BYCOMMAND | MF_DISABLED | MF_GRAYED);
  1849.             }
  1850.  
  1851.             pmnuCtxt->TrackPopupMenu(TPM_LEFTALIGN, point.x, point.y, this, NULL);
  1852.             // Now wait for command messages
  1853.  
  1854.             SetItemState(hItem, 0, TVIS_BOLD );
  1855.         }
  1856.     }
  1857.  
  1858.     // Helper to fix tree control bug
  1859.     if (m_SelItemList.IsEmpty())
  1860.         SelectItem(NULL);
  1861. }
  1862.  
  1863. void CFavOrgTreeCtl::OnKeyDown(UINT nChar, UINT nRepCnt, UINT nFlags) 
  1864. {
  1865.     // Allow scrolling
  1866.     if ((!m_bProcessing)
  1867.         || (((nChar == VK_NEXT) || (nChar == VK_PRIOR)) 
  1868.              && (!(GetKeyState(VK_SHIFT) & 0x8000))
  1869.              && (!(GetKeyState(VK_CONTROL) & 0x8000))
  1870.              && (!(GetKeyState(VK_MENU) & 0x8000))))
  1871.     {
  1872.         CMultiselTreeCtrl::OnKeyDown(nChar, nRepCnt, nFlags);
  1873.         m_bLetUserScroll = TRUE;
  1874.     }
  1875. }
  1876.  
  1877. int CFavOrgTreeCtl::SetTimeout(int nTimeout)
  1878. {
  1879.     int nTemp = m_nTimeout;
  1880.     m_nTimeout = nTimeout;
  1881.  
  1882.     // Set timeout
  1883.     if (m_pInet != NULL)
  1884.     {
  1885.         int nValue = nTimeout * 1000;
  1886.  
  1887.         m_pInet->SetOption(INTERNET_OPTION_RECEIVE_TIMEOUT, nValue);
  1888.         m_pInet->SetOption(INTERNET_OPTION_SEND_TIMEOUT, nValue);
  1889.         m_pInet->SetOption(INTERNET_OPTION_CONNECT_TIMEOUT, nValue);
  1890.     }
  1891.  
  1892.     return nTemp;
  1893. }
  1894.  
  1895. BOOL CFavOrgTreeCtl::OnSetCursor(CWnd* pWnd, UINT nHitTest, UINT message) 
  1896. {
  1897.     if (m_bProcessing)
  1898.     {
  1899.         SetCursor(LoadCursor(NULL, IDC_WAIT));
  1900.         return(TRUE);
  1901.     }
  1902.  
  1903.     return CMultiselTreeCtrl::OnSetCursor(pWnd, nHitTest, message);
  1904. }
  1905.  
  1906. int CFavOrgTreeCtl::CountFolder(CStringEx sPath)
  1907. {
  1908.     // Count shortcuts in folder
  1909.     CFileFind    finder;
  1910.     CStringEx    sFileSpec;
  1911.     int            nCount = 0;
  1912.  
  1913.     sFileSpec = sPath;
  1914.     sFileSpec.AddSlash();
  1915.     sFileSpec += "*.*";
  1916.  
  1917.     BOOL bOK = finder.FindFile(sFileSpec);
  1918.     while (bOK)
  1919.     {
  1920.         bOK = finder.FindNextFile();
  1921.  
  1922.         CStringEx sFilename = finder.GetFileName();
  1923.  
  1924.         if (finder.IsDirectory() && !finder.IsDots())
  1925.         {
  1926.             CStringEx sNewPath = sPath;
  1927.             sNewPath.AddSlash();
  1928.             nCount += CountFolder(sNewPath + sFilename);
  1929.         }
  1930.         else if (!finder.IsDirectory() 
  1931.                  && 
  1932.                  (sFilename.GetExtension().CompareNoCase(g_szUrlExt) == 0))
  1933.             nCount++;
  1934.  
  1935.         PeekAndYield();
  1936.     }
  1937.  
  1938.     return nCount;
  1939. }
  1940.  
  1941. BOOL CFavOrgTreeCtl::SelectionExist(BOOL& bOneShortcut, BOOL& bOneFolder)
  1942. {
  1943.     bOneShortcut = (m_SelItemList.GetCount() == 1)
  1944.                     &&
  1945.                     (GetItemData(m_SelItemList.GetHead()) != ITEM_IS_FOLDER);
  1946.  
  1947.     bOneFolder = (m_SelItemList.GetCount() == 1)
  1948.                     &&
  1949.                     (GetItemData(m_SelItemList.GetHead()) == ITEM_IS_FOLDER);
  1950.  
  1951.     return !m_SelItemList.IsEmpty();
  1952. }
  1953.  
  1954. int CFavOrgTreeCtl::CountSelected()
  1955. {
  1956.     // Count how many items are selected
  1957.     HTREEITEM hCurItem;
  1958.  
  1959.     if (m_SelItemList.IsEmpty())
  1960.         return 0;
  1961.  
  1962.     hCurItem = m_SelItemList.GetHead();
  1963.  
  1964.     if (GetItemData(hCurItem) == ITEM_IS_FOLDER)
  1965.     {
  1966.         // It's a selection of folders
  1967.         int nCount = 0;
  1968.  
  1969.         POSITION pos = m_SelItemList.GetHeadPosition();
  1970.  
  1971.         while (!m_bCancel && (pos != NULL))
  1972.         {
  1973.             hCurItem = m_SelItemList.GetNext(pos);
  1974.             nCount += CountFolder(MakeFullItemName(hCurItem, FALSE));
  1975.         }
  1976.  
  1977.         return nCount;
  1978.     }
  1979.     else
  1980.         return m_SelItemList.GetCount();
  1981. }
  1982.  
  1983. void CFavOrgTreeCtl::DisplayMsg(int nTitleId, CString sContent)
  1984. {
  1985.     CString sTitle;
  1986.  
  1987.     sTitle.LoadString(nTitleId);
  1988.     m_sCurrentMsg.Format(sTitle, sContent);
  1989.  
  1990.     GetParent()->SendMessage(WM_DISP_MSG, 0, (LPARAM) m_sCurrentMsg.GetBuffer(m_sCurrentMsg.GetLength() + 1));
  1991.     m_sCurrentMsg.ReleaseBuffer(-1);
  1992. }
  1993.  
  1994. void CFavOrgTreeCtl::ClearMsg()
  1995. {
  1996.     GetParent()->SendMessage(WM_DISP_MSG, 0, NULL);    
  1997. }
  1998.  
  1999. void CFavOrgTreeCtl::UpdateItemIcon(HTREEITEM hItem, HICON hIcon, CString sIconFilename, int nIndex)
  2000. {
  2001.     // Change the icon of a given shortcut
  2002.     CString sFilename = MakeFullItemName(hItem, TRUE);
  2003.  
  2004.     IUniformResourceLocatorPtr pNewUrlLink(CLSID_InternetShortcut, NULL, CLSCTX_INPROC_SERVER);
  2005.     IUniformResourceLocatorPtr pUrlLink(CLSID_InternetShortcut, NULL, CLSCTX_INPROC_SERVER);
  2006.     if ((pUrlLink != NULL) && (pNewUrlLink != NULL))
  2007.     {
  2008.         IPersistFilePtr pNewpf(pNewUrlLink);
  2009.         IPersistFilePtr ppf(pUrlLink);
  2010.  
  2011.         if ((ppf != NULL) && (pNewpf != NULL))
  2012.         { 
  2013.             WCHAR wsz[MAX_PATH];
  2014.  
  2015.             // Use UNICODE string anyway
  2016.             MultiByteToWideChar(CP_ACP, 0, sFilename, -1, wsz, MAX_PATH);
  2017.             // Load the shortcut. 
  2018.             if (SUCCEEDED(ppf->Load(wsz, STGM_READ)))
  2019.             {
  2020.                 IShellLinkPtr psl(pNewUrlLink);
  2021.  
  2022.                 if (psl != NULL)
  2023.                 {
  2024.                     LPSTR lpszCurrentURL;
  2025.  
  2026.                     pUrlLink->GetURL(&lpszCurrentURL);
  2027.                     pNewUrlLink->SetURL(lpszCurrentURL, IURL_SETURL_FL_GUESS_PROTOCOL);
  2028.                     SetItemIcon(hItem, sIconFilename, hIcon, nIndex, psl);
  2029.                     DeleteFile(sFilename);
  2030.                     pNewpf->Save(wsz, TRUE);
  2031.  
  2032.                     // A trick to make sure that the newly assigned
  2033.                     // image is correctly refreshed. Bug in tree control?
  2034.                     int nImage, nSelectedImage;
  2035.                     GetItemImage(hItem, nImage, nSelectedImage);
  2036.                     SetItemImage(hItem, nImage, nSelectedImage);
  2037.  
  2038.                     if (!m_bLetUserScroll)
  2039.                         EnsureVisible(hItem);
  2040.                 }
  2041.             }
  2042.         }
  2043.     }
  2044.  
  2045.     if (m_pProgressCtl)
  2046.         m_pProgressCtl->OffsetPos(1);
  2047. }
  2048.  
  2049. void CFavOrgTreeCtl::ProcessItemIcon(HTREEITEM hItem, HICON hIcon, CString sIconFilename, int nIndex)
  2050. {
  2051.     if (GetItemData(hItem) == ITEM_IS_FOLDER)
  2052.     {
  2053.         // It's a folder (we have a selection of folders)
  2054.         // Process all items in this folder
  2055.         HTREEITEM hChildItem = GetChildItem(hItem);
  2056.  
  2057.         while (!m_bCancel && (hChildItem != NULL))
  2058.         {
  2059.             if (GetItemData(hChildItem) == ITEM_IS_FOLDER)
  2060.                 ProcessItemIcon(hChildItem, hIcon, sIconFilename, nIndex);
  2061.             else
  2062.                 UpdateItemIcon(hChildItem, hIcon, sIconFilename, nIndex);
  2063.             hChildItem = GetNextItem(hChildItem, TVGN_NEXT);
  2064.         }
  2065.  
  2066.         if (m_bCancel)
  2067.             GetParent()->PostMessage(WM_CAN_UNLOCK, 0, 0);
  2068.  
  2069.         if (!m_bLetUserScroll)
  2070.             EnsureVisible(hItem);
  2071.     }
  2072.     else
  2073.         UpdateItemIcon(hItem, hIcon, sIconFilename, nIndex);
  2074. }
  2075.  
  2076. void CFavOrgTreeCtl::AssignCustomIcon(CString sIconFilename, int nIconIndex, HTREEITEM hItem)
  2077. {
  2078.     if ((m_SelItemList.IsEmpty()) && (hItem == NULL)) 
  2079.         return;
  2080.  
  2081.     HICON hIconLarge, hIconSmall;
  2082.  
  2083.     m_bLetUserScroll = FALSE;
  2084.  
  2085.     // Is there any icon in that file?
  2086.     ExtractIconEx(sIconFilename, nIconIndex, &hIconLarge, &hIconSmall, 1);
  2087.  
  2088.     if (hIconSmall == NULL)
  2089.     {
  2090.         hIconSmall = hIconLarge; 
  2091.         hIconLarge = NULL;
  2092.     }
  2093.  
  2094.     if (hIconSmall != NULL)
  2095.     {
  2096.         // Yes - assign it
  2097.         HTREEITEM    hCurItem;
  2098.  
  2099.         if (hItem != NULL)
  2100.         {
  2101.             // Just process this one)
  2102.             ProcessItemIcon(hItem, hIconSmall, sIconFilename, nIconIndex);
  2103.             return;
  2104.         }
  2105.  
  2106.         m_bCancel = FALSE;
  2107.         m_bProcessing = TRUE;
  2108.  
  2109.         if (m_pProgressCtl)
  2110.         {
  2111.             m_pProgressCtl->SetStep(1);
  2112.             m_pProgressCtl->SetPos(0);
  2113.         }
  2114.  
  2115.         POSITION pos;
  2116.  
  2117.         if (AfxMessageBox(IDS_ASSIGNSELALERT, MB_YESNO | MB_ICONEXCLAMATION, 0) == IDNO)
  2118.             goto stopprocess;
  2119.  
  2120.         if (m_pProgressCtl)
  2121.             m_pProgressCtl->SetRange32(0, m_nLoadedItems);
  2122.  
  2123.         // Enumerate selected items    
  2124.         pos = m_SelItemList.GetHeadPosition();
  2125.  
  2126.         while (!m_bCancel && (pos != NULL))
  2127.         {
  2128.             hCurItem = m_SelItemList.GetNext(pos);
  2129.             ProcessItemIcon(hCurItem, hIconSmall, sIconFilename, nIconIndex);
  2130.         }
  2131.  
  2132. stopprocess:
  2133.  
  2134.         if (m_bCancel)
  2135.             GetParent()->PostMessage(WM_CAN_UNLOCK, 0, 0);
  2136.  
  2137.         m_bCancel = FALSE;
  2138.         if (m_pProgressCtl)
  2139.             m_pProgressCtl->SetPos(0);
  2140.  
  2141.         DestroyIcon(hIconSmall);
  2142.         Invalidate();
  2143.         UpdateWindow();
  2144.  
  2145.         SetCursor(LoadCursor(NULL, IDC_ARROW));
  2146.         m_bProcessing = FALSE;
  2147.     }
  2148. }
  2149.  
  2150. void CFavOrgTreeCtl::AssignThisImage(HTREEITEM hItem)
  2151. {
  2152.     // Assign the picked up icon to the selected shortcuts
  2153.     IUniformResourceLocatorPtr pUrlLink(CLSID_InternetShortcut, NULL, CLSCTX_INPROC_SERVER);
  2154.     if (pUrlLink != NULL)
  2155.     {
  2156.         IShellLinkPtr psl(pUrlLink);
  2157.         IPersistFilePtr ppf(pUrlLink);  
  2158.     
  2159.         if (ppf != NULL)
  2160.         { 
  2161.             WCHAR wsz[MAX_PATH];
  2162.  
  2163.             MultiByteToWideChar(CP_ACP, 0, m_sPickedShortcut, -1, wsz, MAX_PATH);
  2164.             // Load the shortcut. 
  2165.             if (SUCCEEDED(ppf->Load(wsz, STGM_READ)))
  2166.             {
  2167.                 CString    sIconFile;
  2168.                 int        nIndex;
  2169.  
  2170.                 psl->GetIconLocation(sIconFile.GetBuffer(MAX_PATH), MAX_PATH, &nIndex);
  2171.                 sIconFile.ReleaseBuffer();
  2172.                 AssignCustomIcon(sIconFile, nIndex, hItem);
  2173.             }
  2174.         }
  2175.     }
  2176. }
  2177.  
  2178. void CFavOrgTreeCtl::PickCurrentIcon(HTREEITEM hItem)
  2179. {
  2180.     // Get the icon of the currently selected shorcut
  2181.     if ((m_SelItemList.GetCount() == 1) || (hItem != NULL))
  2182.     {
  2183.         HTREEITEM hSourceItem;
  2184.         
  2185.         if (hItem)
  2186.             hSourceItem = hItem;
  2187.         else
  2188.             hSourceItem = GetSelectedItem();
  2189.  
  2190.         if (GetItemData(hSourceItem) != ITEM_IS_FOLDER)
  2191.         {
  2192.             CString sFilename = MakeFullItemName(hSourceItem, TRUE);
  2193.             CString sUrl;
  2194.             int nSelected, nNotSelected;
  2195.  
  2196.             GetItemImage(hSourceItem, nNotSelected, nSelected);
  2197.             GetParent()->SendMessage(WM_DISP_ICON, 0, (LPARAM) m_imgStd.ExtractIcon(nNotSelected));    
  2198.             m_sPickedShortcut = sFilename;
  2199.         }
  2200.     }
  2201. }
  2202.  
  2203. void CFavOrgTreeCtl::DestroyItem(HTREEITEM hItem, BOOL bIsDir)
  2204. {
  2205.     // No permanent delete - always send to Recycle Bin
  2206.     // (unless the Favorites folder is a network share)
  2207.     CString sName = MakeFullItemName(hItem, !bIsDir);
  2208.  
  2209.     char szBuffer[MAX_PATH + 1];
  2210.  
  2211.     strcpy(szBuffer, sName.GetBuffer(MAX_PATH));
  2212.     szBuffer[strlen(szBuffer) + 1] = '\0';
  2213.  
  2214.     SHFILEOPSTRUCT shfo;
  2215.  
  2216.     ZeroMemory(&shfo, sizeof(SHFILEOPSTRUCT));
  2217.     shfo.hwnd = m_hWnd;
  2218.     shfo.wFunc = FO_DELETE;
  2219.     shfo.fFlags = FOF_NOCONFIRMATION | FOF_ALLOWUNDO;
  2220.     shfo.pFrom = szBuffer;
  2221.  
  2222.     if (SHFileOperation(&shfo) == 0)
  2223.     {
  2224.         // Remove item from tree
  2225.         DeleteItem(hItem);
  2226.         if (!bIsDir)
  2227.         {
  2228.             m_nLoadedItems--;
  2229.             m_nNumItems--;
  2230.         }
  2231.     }
  2232. }
  2233.  
  2234. void CFavOrgTreeCtl::RemoveItem(HTREEITEM hItem)
  2235. {
  2236.     if (GetItemData(hItem) == ITEM_IS_FOLDER)
  2237.     {
  2238.         // It's a folder (we have a selection of folders)
  2239.         // Process all items in this folder
  2240.         HTREEITEM hChildItem = GetChildItem(hItem);
  2241.         HTREEITEM hNextItem;
  2242.  
  2243.         while (!m_bCancel && (hChildItem != NULL))
  2244.         {
  2245.             hNextItem = GetNextItem(hChildItem, TVGN_NEXT);
  2246.             if (GetItemData(hChildItem) == ITEM_IS_FOLDER)
  2247.                 RemoveItem(hChildItem);
  2248.             else
  2249.                 DestroyItem(hChildItem, FALSE);
  2250.             hChildItem = hNextItem;
  2251.         }
  2252.  
  2253.         DestroyItem(hItem, TRUE);
  2254.  
  2255.         if (m_bCancel)
  2256.             GetParent()->PostMessage(WM_CAN_UNLOCK, 0, 0);
  2257.     }
  2258.     else
  2259.         DestroyItem(hItem, FALSE);
  2260. }
  2261.  
  2262. void CFavOrgTreeCtl::RemoveSelected()
  2263. {
  2264.     if (m_SelItemList.IsEmpty())
  2265.         return;
  2266.  
  2267.     HTREEITEM    hCurItem;
  2268.  
  2269.     m_bCancel = FALSE;
  2270.     m_bProcessing = TRUE;
  2271.  
  2272.     if (m_pProgressCtl)
  2273.     {
  2274.         m_pProgressCtl->SetStep(1);
  2275.         m_pProgressCtl->SetPos(0);
  2276.     }
  2277.  
  2278.     if (m_pProgressCtl)
  2279.         m_pProgressCtl->SetRange32(0, CountSelected());
  2280.  
  2281.     // Enumerate selected items    
  2282.     POSITION pos = m_SelItemList.GetHeadPosition();
  2283.  
  2284.     while (!m_bCancel && (pos != NULL))
  2285.     {
  2286.         hCurItem = m_SelItemList.GetNext(pos);
  2287.         if (hCurItem == m_hRootItem)
  2288.         {
  2289.             if (AfxMessageBox(IDS_DELETEALLALERT, MB_YESNO | MB_ICONEXCLAMATION, 0) != IDYES)
  2290.                 goto stopdeleteprocess;
  2291.         }
  2292.         RemoveItem(hCurItem);
  2293.     }
  2294.  
  2295. stopdeleteprocess:
  2296.  
  2297.     ClearSelection(TRUE);
  2298.  
  2299.     if (m_bCancel)
  2300.         GetParent()->PostMessage(WM_CAN_UNLOCK, 0, 0);
  2301.  
  2302.     m_bCancel = FALSE;
  2303.     if (m_pProgressCtl)
  2304.         m_pProgressCtl->SetPos(0);
  2305.  
  2306.     Invalidate();
  2307.  
  2308.     SetCursor(LoadCursor(NULL, IDC_ARROW));
  2309.     m_bProcessing = FALSE;
  2310. }
  2311.  
  2312. void CFavOrgTreeCtl::OnBeginLabelEdit(NMHDR* pNMHDR, LRESULT* pResult) 
  2313. {
  2314.     // Handle edition of item (shorcut) name
  2315.     // (F2 or two clicks)
  2316.     TVITEM    TvItem = ((TV_DISPINFO*)pNMHDR)->item;
  2317.  
  2318.     // Subclass edit control with our CTreeCtrlEdit    
  2319.     m_ctlEdit.SubclassWindow(GetEditControl()->m_hWnd);
  2320.     m_ctlEdit.SetCurItem(TvItem.hItem);
  2321.     m_ctlEdit.SetTreeCtrl(this);
  2322.  
  2323.     if ((TvItem.mask & TVIF_TEXT) != 0)
  2324.     {
  2325.         BOOL bIsDir = GetItemData(TvItem.hItem) == ITEM_IS_FOLDER;
  2326.  
  2327.         m_sOldLabel = TvItem.pszText;
  2328.         m_sOldFilename = MakeFullItemName(TvItem.hItem, !bIsDir);
  2329.     }
  2330.  
  2331.     *pResult = 0;
  2332. }
  2333.  
  2334. void CFavOrgTreeCtl::OnEndLabelEdit(NMHDR* pNMHDR, LRESULT* pResult) 
  2335. {
  2336.     // Handle edition of item (shorcut) name
  2337.     // (F2 or two clicks)
  2338.     TVITEM    TvItem = ((TV_DISPINFO*)pNMHDR)->item;
  2339.  
  2340.     if ((TvItem.mask & TVIF_TEXT) != 0)
  2341.     {
  2342.         if ((TvItem.pszText != NULL) && (m_sOldLabel.CompareNoCase(TvItem.pszText) != 0))
  2343.         {
  2344.             BOOL bIsDir = GetItemData(TvItem.hItem) == ITEM_IS_FOLDER;
  2345.  
  2346.             CStringEx sNewName;
  2347.  
  2348.             sNewName = m_sOldFilename;
  2349.             sNewName.ReplaceNameComponent(CString(TvItem.pszText), EX_STRING_REPNAME);
  2350.             if (!MoveFile(m_sOldFilename, sNewName))
  2351.                 // Restore old name if failed
  2352.                 SetItemText(TvItem.hItem, m_sOldLabel);
  2353.         }
  2354.     }
  2355.  
  2356.     m_ctlEdit.UnsubclassWindow();
  2357.     m_ctlEdit.SetCurItem(NULL);
  2358.     m_ctlEdit.SetTreeCtrl(NULL);
  2359.  
  2360.     *pResult = 0;
  2361. }
  2362.  
  2363. void CFavOrgTreeCtl::OnSelChanged(NMHDR* pNMHDR, LRESULT* pResult) 
  2364. {
  2365.     // Activate edition of the URL when a single item is selected
  2366.     HTREEITEM hItem = GetSelectedItem();
  2367.  
  2368.     if ((m_SelItemList.GetCount() == 1)
  2369.         ||
  2370.         ((m_SelItemList.GetCount() == 0) && (hItem != NULL)))
  2371.     {
  2372.         if ((hItem != NULL) && (GetItemData(hItem) != ITEM_IS_FOLDER))
  2373.         {
  2374.             CString sFilename = MakeFullItemName(hItem, TRUE);
  2375.             CString sUrl;
  2376.  
  2377.             GetOrSetURLFromShortcut(sFilename, sUrl, TRUE);
  2378.             GetParent()->SendMessage(WM_DISP_MSG, 0, (LPARAM) sUrl.GetBuffer(sUrl.GetLength() + 1));    
  2379.             sUrl.ReleaseBuffer(-1);
  2380.         }
  2381.         else
  2382.             goto folderselected;
  2383.     }
  2384.     else
  2385.     {
  2386. folderselected:
  2387.         GetParent()->SendMessage(WM_DISP_MSG, 0, NULL);    
  2388.     }
  2389.     
  2390.     *pResult = 0;
  2391. }
  2392.  
  2393. void CFavOrgTreeCtl::UpdateUrl(HTREEITEM hItem)
  2394. {
  2395.     // Update URL with new name
  2396.     if ((m_SelItemList.GetCount() == 1) || (hItem != NULL))
  2397.     {
  2398.         HTREEITEM hSourceItem;
  2399.         
  2400.         if (hItem)
  2401.             hSourceItem = hItem;
  2402.         else
  2403.             hSourceItem = GetSelectedItem();
  2404.  
  2405.         if (GetItemData(hSourceItem) != ITEM_IS_FOLDER)
  2406.         {
  2407.             CString sFilename = MakeFullItemName(hSourceItem, TRUE);
  2408.             CEditUrlDlg dlg;
  2409.  
  2410.             GetOrSetURLFromShortcut(sFilename, dlg.m_sRefLabel, TRUE);
  2411.  
  2412.             dlg.m_sNewUrl = dlg.m_sRefLabel;
  2413.             if (dlg.DoModal() == IDOK)
  2414.                 GetOrSetURLFromShortcut(sFilename, dlg.m_sNewUrl, FALSE);
  2415.  
  2416.             GetParent()->SendMessage(WM_DISP_MSG, 0, (LPARAM) dlg.m_sNewUrl.GetBuffer(dlg.m_sNewUrl.GetLength() + 1));
  2417.             dlg.m_sNewUrl.ReleaseBuffer(-1);
  2418.         }
  2419.     }
  2420. }
  2421.  
  2422. void CFavOrgTreeCtl::PeekAndYield()
  2423. {
  2424.     // A helper yielding control to the main window
  2425.     MSG     Msg;
  2426.  
  2427.     while(PeekMessage(&Msg, NULL, 0, 0, PM_REMOVE))
  2428.     {
  2429.         if (!::IsDialogMessage(AfxGetMainWnd()->m_hWnd, &Msg))
  2430.         {
  2431.             TranslateMessage(&Msg);
  2432.             DispatchMessage(&Msg);
  2433.         }
  2434.     }
  2435.  
  2436.     if (!m_sCurrentMsg.IsEmpty())
  2437.     {
  2438.         GetParent()->SendMessage(WM_DISP_MSG, 0, (LPARAM) m_sCurrentMsg.GetBuffer(m_sCurrentMsg.GetLength() + 1));    
  2439.         m_sCurrentMsg.ReleaseBuffer(-1);
  2440.     }
  2441. }
  2442.  
  2443. void CFavOrgTreeCtl::ModifyStates(HTREEITEM hItem, int nStateIndex)
  2444. {
  2445.     // Modify state of selection or single item when receiving
  2446.     // the corresponding command from the popup context menu
  2447.     if (hItem != NULL)
  2448.     {
  2449.         if (GetItemData(hItem) == ITEM_IS_FOLDER)
  2450.         {
  2451.             // It's a folder
  2452.             // Process all items in this folder
  2453.             HTREEITEM hChildItem = GetChildItem(hItem);
  2454.  
  2455.             while (hChildItem != NULL)
  2456.             {
  2457.                 if (GetItemData(hChildItem) == ITEM_IS_FOLDER)
  2458.                     ModifyStates(hChildItem, nStateIndex);
  2459.                 else
  2460.                     SetItemState(hChildItem, INDEXTOSTATEIMAGEMASK(nStateIndex), TVIS_STATEIMAGEMASK);
  2461.                 hChildItem = GetNextItem(hChildItem, TVGN_NEXT);
  2462.             }
  2463.         }
  2464.         else
  2465.             SetItemState(hItem, INDEXTOSTATEIMAGEMASK(nStateIndex), TVIS_STATEIMAGEMASK);
  2466.     }
  2467.     else if (!m_SelItemList.IsEmpty())
  2468.     {
  2469.         // Modify state of selection
  2470.         POSITION pos = m_SelItemList.GetHeadPosition();
  2471.         HTREEITEM hCurItem;
  2472.  
  2473.         while (pos != NULL)
  2474.         {
  2475.             hCurItem = m_SelItemList.GetNext(pos);
  2476.             ModifyStates(hCurItem, nStateIndex);
  2477.         }
  2478.     }
  2479. }
  2480.  
  2481. BOOL CFavOrgTreeCtl::ExecLocalCommand(UINT nID, BOOL bFromContextMenu)
  2482. {
  2483.     switch(nID)
  2484.     {
  2485.         case IDC_MNU_QUESTION:
  2486.         case IDC_MNU_CHECKED:
  2487.         case IDC_MNU_PAGENONE:
  2488.         case IDC_MNU_MOVED:
  2489.         case IDC_MNU_SITENONE:
  2490.         case IDC_MNU_TIMEOUT:
  2491.         case IDC_MNU_ACCESSDENIED:
  2492.         case IDC_MNU_MOVED_UPDATED:
  2493.         case IDC_MNU_UNCHECKED:
  2494.         case IDC_MNU_RESET:
  2495.         {
  2496.             // Item state has been changed
  2497.             int nStateIndex = nID - 500;
  2498.  
  2499.             if (!bFromContextMenu || (m_hLastCtxtItem == NULL) || (GetItemData(m_hLastCtxtItem) == ITEM_IS_FOLDER))
  2500.             {
  2501.                 m_bProcessing = TRUE;
  2502.                 m_bCancel = FALSE;
  2503.  
  2504.                 ModifyStates(m_hLastCtxtItem, nStateIndex);
  2505.  
  2506.                 m_bCancel = FALSE;
  2507.                 m_bProcessing = FALSE;
  2508.             }
  2509.             else
  2510.                 SetItemState(m_hLastCtxtItem, INDEXTOSTATEIMAGEMASK(nStateIndex), TVIS_STATEIMAGEMASK);
  2511.  
  2512.             return TRUE;
  2513.         }
  2514.  
  2515.         case IDC_DISPINFO:
  2516.             // Display item info
  2517.             CString* psItemData;
  2518.  
  2519.             if (!bFromContextMenu)
  2520.                 psItemData = (CString*) GetItemData(GetSelectedItem());
  2521.             else
  2522.                 psItemData = (CString*) GetItemData(m_hLastCtxtItem);
  2523.  
  2524.             AfxMessageBox(*psItemData, MB_OK | MB_ICONINFORMATION, 0);
  2525.             
  2526.             return TRUE;
  2527.  
  2528.         case IDC_REMOVE:
  2529.             if (AfxMessageBox(IDS_DELETESELALERT, MB_YESNO | MB_ICONEXCLAMATION, 0) != IDYES)
  2530.                 return TRUE;
  2531.  
  2532.             // Delete item
  2533.             if (m_hLastCtxtItem == NULL)
  2534.                 // Destroy selection
  2535.                 RemoveSelected();
  2536.             else
  2537.                 DestroyItem(m_hLastCtxtItem, GetItemData(m_hLastCtxtItem) == ITEM_IS_FOLDER);
  2538.  
  2539.             GetParent()->SendMessage(WM_REFRESH_COUNT, 0, 0);
  2540.  
  2541.             return TRUE;
  2542.  
  2543.         case IDC_PICKICON:
  2544.             if (bFromContextMenu)
  2545.                 PickCurrentIcon(m_hLastCtxtItem);
  2546.             else
  2547.                 PickCurrentIcon(NULL);
  2548.             
  2549.             return TRUE;
  2550.  
  2551.         case IDC_ASSIGNTHIS:
  2552.             if (bFromContextMenu)
  2553.                 AssignThisImage(m_hLastCtxtItem);
  2554.             else
  2555.                 AssignThisImage(GetSelectedItem());
  2556.             
  2557.             return TRUE;
  2558.  
  2559.         case IDC_ASSIGNCUST:
  2560.             {
  2561.                 DWORD        nIconIndex = 0;
  2562.                 CStringEx    sIconFilename;
  2563.  
  2564.                 GetSystemDirectory(sIconFilename.GetBuffer(MAX_PATH), MAX_PATH);
  2565.                 sIconFilename.ReleaseBuffer(-1);
  2566.                 sIconFilename.AddSlash();
  2567.                 sIconFilename += "url.dll";
  2568.                 
  2569.                 if (!SelectIcon(AfxGetMainWnd()->m_hWnd, sIconFilename.GetBuffer(MAX_PATH), MAX_PATH, &nIconIndex))
  2570.                 {
  2571.                     sIconFilename.ReleaseBuffer(-1);
  2572.                     return TRUE;
  2573.                 }
  2574.  
  2575.                 sIconFilename.ReleaseBuffer(-1);
  2576.                 AssignCustomIcon(sIconFilename, nIconIndex, m_hLastCtxtItem);
  2577.                 
  2578.                 return TRUE;
  2579.             }
  2580.  
  2581.         case IDC_EDITURL:
  2582.             if (bFromContextMenu)
  2583.                 UpdateUrl(m_hLastCtxtItem);
  2584.             else
  2585.                 UpdateUrl(GetSelectedItem());
  2586.             
  2587.             return TRUE;
  2588.  
  2589.         default:
  2590.             return FALSE;
  2591.     }
  2592. }
  2593.  
  2594. BOOL CFavOrgTreeCtl::OnCmdMsg(UINT nID, int nCode, void* pExtra, AFX_CMDHANDLERINFO* pHandlerInfo) 
  2595. {
  2596.     // Handle commands triggered by the context menu
  2597.     if ((nCode == 0) && ExecLocalCommand(nID, TRUE))
  2598.     {
  2599.         m_hLastCtxtItem = NULL;
  2600.         return TRUE;
  2601.     }
  2602.     else
  2603.         return CMultiselTreeCtrl::OnCmdMsg(nID, nCode, pExtra, pHandlerInfo);
  2604. }
  2605.  
  2606. void CFavOrgTreeCtl::ClearItemdata(HTREEITEM hItem)
  2607. {
  2608.     // Reset item data for the whole tree
  2609.     if (GetItemData(hItem) == ITEM_IS_FOLDER)
  2610.     {
  2611.         // It's a folder
  2612.         // Process all items in this folder
  2613.         HTREEITEM hChildItem = GetChildItem(hItem);
  2614.  
  2615.         while (hChildItem != NULL)
  2616.         {
  2617.             if (GetItemData(hChildItem) == ITEM_IS_FOLDER)
  2618.                 ClearItemdata(hChildItem);
  2619.             else
  2620.             {
  2621.                 DWORD dwData = GetItemData(hChildItem);
  2622.                 if ((dwData != ITEM_IS_FOLDER) && ((dwData != 0)))
  2623.                     delete (CString*) dwData;
  2624.             }
  2625.             hChildItem = GetNextItem(hChildItem, TVGN_NEXT);
  2626.         }
  2627.     }
  2628.     else
  2629.     {
  2630.         DWORD dwData = GetItemData(hItem);
  2631.         if ((dwData != ITEM_IS_FOLDER) && (dwData != 0))
  2632.             delete (CString*) dwData;
  2633.     }
  2634. }
  2635.  
  2636.  
  2637. void CFavOrgTreeCtl::GenerateLogEntry(CFile* pLogfile, HTREEITEM hItem)
  2638. {
  2639.     CString sName = MakeFullItemName(hItem, TRUE);
  2640.     CString sURL;
  2641.  
  2642.     // Get URL
  2643.     if (GetOrSetURLFromShortcut(sName, sURL, TRUE))
  2644.     {
  2645.         CString sEntry = "\r\n\t" + sName + "\r\n\t" + sURL + "\r\n";
  2646.         OutputString(sEntry, pLogfile);
  2647.     }
  2648.  
  2649.     // Get status
  2650.     int nState = GetItemState(hItem, TVIS_STATEIMAGEMASK) & ~0xFF;
  2651.     CString sState;
  2652.     int nStringId;
  2653.  
  2654.     // Create status string
  2655.     switch(nState)
  2656.     {
  2657.         case INDEXTOSTATEIMAGEMASK(STATE_INDEX_QUESTION):
  2658.             nStringId = IDS_STATUS_UNKNOWN;
  2659.             break;
  2660.         case INDEXTOSTATEIMAGEMASK(STATE_INDEX_CHECKED):
  2661.             nStringId = IDS_STATUS_CHECKED;
  2662.             break;
  2663.         case INDEXTOSTATEIMAGEMASK(STATE_INDEX_PAGENONE):
  2664.             nStringId = IDS_STATUS_PAGENOTFOUND;
  2665.             break;
  2666.         case INDEXTOSTATEIMAGEMASK(STATE_INDEX_MOVED):
  2667.             nStringId = IDS_STATUS_PAGEMOVED;
  2668.             break;
  2669.         case INDEXTOSTATEIMAGEMASK(STATE_INDEX_TIMEOUT):
  2670.             nStringId = IDS_STATUS_TIMEOUT;
  2671.             break;
  2672.         case INDEXTOSTATEIMAGEMASK(STATE_INDEX_SITENONE):
  2673.             nStringId = IDS_STATUS_SITENOTFOUND;
  2674.             break;
  2675.         case INDEXTOSTATEIMAGEMASK(STATE_INDEX_ACCESSDENIED):
  2676.             nStringId = IDS_STATUS_ACCESSDENIED;
  2677.             break;
  2678.         case INDEXTOSTATEIMAGEMASK(STATE_INDEX_MOVED_UPDATED):
  2679.             nStringId = IDS_STATUS_MOVEDUPDATED;
  2680.             break;
  2681.         case INDEXTOSTATEIMAGEMASK(STATE_INDEX_UNCHECKED):
  2682.             nStringId = IDS_STATUS_UNCHECKED;
  2683.             break;
  2684.         case INDEXTOSTATEIMAGEMASK(STATE_INDEX_RESET):
  2685.             nStringId = IDS_STATUS_RESET;
  2686.             break;
  2687.  
  2688.     }
  2689.  
  2690.     sState.LoadString(nStringId);
  2691.     sState = "\tStatus : " + sState + "\r\n";
  2692.     OutputString(sState, pLogfile);
  2693.  
  2694.     // Get icon location
  2695.     IUniformResourceLocatorPtr pUrlLink(CLSID_InternetShortcut, NULL, CLSCTX_INPROC_SERVER);
  2696.     if (pUrlLink != NULL)
  2697.     {
  2698.         IShellLinkPtr psl(pUrlLink);
  2699.         IPersistFilePtr ppf(pUrlLink);  
  2700.     
  2701.         if (ppf != NULL)
  2702.         { 
  2703.             WCHAR wsz[MAX_PATH];
  2704.             CString sItemName = MakeFullItemName(hItem, TRUE);
  2705.  
  2706.             MultiByteToWideChar(CP_ACP, 0, sItemName, -1, wsz, MAX_PATH);
  2707.             // Load the shortcut. 
  2708.             if (SUCCEEDED(ppf->Load(wsz, STGM_READ)))
  2709.             {
  2710.                 CString    sIconFile;
  2711.                 int        nIndex;
  2712.  
  2713.                 psl->GetIconLocation(sIconFile.GetBuffer(MAX_PATH), MAX_PATH, &nIndex);
  2714.                 sIconFile.ReleaseBuffer();
  2715.  
  2716.                 CString sIconDesc;
  2717.  
  2718.                 sIconDesc.Format("\tIcon Location : %s - Index : %d\r\n", sIconFile, nIndex);
  2719.                 OutputString(sIconDesc, pLogfile);
  2720.             }
  2721.         }
  2722.     }
  2723.  
  2724.     // Get raw header retrieved from the response header
  2725.     DWORD dwData;
  2726.     if ((dwData = GetItemData(hItem)) != 0)
  2727.     {
  2728.         OutputString(CString("\t---------------\r\n"), pLogfile);
  2729.  
  2730.         CStringEx sMsg = *((CString*) dwData);
  2731.         sMsg = "\t" + sMsg;
  2732.  
  2733.         for (int nIndex = sMsg.GetLength() - 1; nIndex > 0; nIndex --)
  2734.         {
  2735.             if (sMsg.GetAt(nIndex) == (char) 0x0A)
  2736.                 sMsg.InsertChar((char) 0x09, nIndex + 1);
  2737.         }
  2738.  
  2739.         OutputString(sMsg, pLogfile);
  2740.     }
  2741.  
  2742.     PeekAndYield();
  2743.  
  2744.     if (m_pProgressCtl)
  2745.         m_pProgressCtl->OffsetPos(1);
  2746. }
  2747.  
  2748. void CFavOrgTreeCtl::GenerateLogEntries(CFile* pLogfile, HTREEITEM hItem)
  2749. {
  2750.     if (GetItemData(hItem) == ITEM_IS_FOLDER)
  2751.     {
  2752.         // It's a folder
  2753.         CString sFolderTitle = "\r\nFolder : " + MakeFullItemName(hItem, FALSE) + "\r\n";
  2754.         OutputString(sFolderTitle, pLogfile);
  2755.  
  2756.         // Process all items in this folder
  2757.         HTREEITEM hChildItem = GetChildItem(hItem);
  2758.  
  2759.         while (!m_bCancel && (hChildItem != NULL))
  2760.         {
  2761.             if (GetItemData(hChildItem) == ITEM_IS_FOLDER)
  2762.                 GenerateLogEntries(pLogfile, hChildItem);
  2763.             else
  2764.                 GenerateLogEntry(pLogfile, hChildItem);
  2765.             hChildItem = GetNextItem(hChildItem, TVGN_NEXT);
  2766.         }
  2767.  
  2768.         if (m_bCancel)
  2769.             GetParent()->PostMessage(WM_CAN_UNLOCK, 0, 0);
  2770.     }
  2771.     else
  2772.         GenerateLogEntry(pLogfile, hItem);
  2773. }
  2774.  
  2775. void CFavOrgTreeCtl::GenerateLog(CString sLogName)
  2776. {
  2777.     m_bProcessing = TRUE;
  2778.     m_bCancel = FALSE;
  2779.  
  2780.     try
  2781.     {
  2782.         CFile logfile(sLogName, CFile::modeCreate | CFile::modeWrite | CFile::shareExclusive);
  2783.  
  2784.         CString sHeader;
  2785.         CString sDate;
  2786.         CString sTime;
  2787.  
  2788.         // Create time stamp
  2789.         GetDateFormat(LOCALE_USER_DEFAULT, 0, NULL, NULL, sDate.GetBuffer(50), 50);
  2790.         sDate.ReleaseBuffer();
  2791.         GetTimeFormat(LOCALE_USER_DEFAULT, 0, NULL, NULL, sTime.GetBuffer(50), 50);
  2792.         sTime.ReleaseBuffer();
  2793.  
  2794.         sHeader.Format("FavOrg report - %s - %s\r\n\r\n", sDate, sTime);
  2795.         OutputString(sHeader, &logfile);
  2796.  
  2797.         HTREEITEM hCurItem;
  2798.  
  2799.         if (!m_SelItemList.IsEmpty())
  2800.         {
  2801.             // Enumerate selection
  2802.             if (m_pProgressCtl)
  2803.                 m_pProgressCtl->SetRange32(0, CountSelected());
  2804.  
  2805.             // We have a selection
  2806.             POSITION pos = m_SelItemList.GetHeadPosition();
  2807.  
  2808.             while (!m_bCancel && (pos != NULL))
  2809.             {
  2810.                 hCurItem = m_SelItemList.GetNext(pos);
  2811.                 GenerateLogEntries(&logfile, hCurItem);
  2812.             }
  2813.         }
  2814.         else
  2815.         {
  2816.             // Enumerate tree
  2817.             if (m_pProgressCtl)
  2818.                 m_pProgressCtl->SetRange32(0, m_nLoadedItems);
  2819.  
  2820.             hCurItem = GetChildItem(m_hRootItem);
  2821.             while (!m_bCancel && (hCurItem != NULL))
  2822.             {
  2823.                 GenerateLogEntries(&logfile, hCurItem);
  2824.                 hCurItem = GetNextItem(hCurItem, TVGN_NEXT);
  2825.             }
  2826.         }
  2827.  
  2828.         logfile.Close();
  2829.     }
  2830.  
  2831.     catch(CFileException* pEx)
  2832.     {
  2833.         pEx->Delete();
  2834.  
  2835.         DisplayMsg(IDS_MSG_LOGERROR, sLogName);
  2836.  
  2837.         m_bCancel = FALSE;
  2838.         if (m_pProgressCtl)
  2839.             m_pProgressCtl->SetPos(0);
  2840.  
  2841.         SetCursor(LoadCursor(NULL, IDC_ARROW));
  2842.         m_bProcessing = FALSE;
  2843.  
  2844.         return;
  2845.     }
  2846.  
  2847.     m_bCancel = FALSE;
  2848.     if (m_pProgressCtl)
  2849.         m_pProgressCtl->SetPos(0);
  2850.  
  2851.     SetCursor(LoadCursor(NULL, IDC_ARROW));
  2852.     m_bProcessing = FALSE;
  2853. }
  2854.  
  2855. void CFavOrgTreeCtl::OutputString(CString sText, CFile* pLogfile)
  2856. {
  2857.     // We need a special function managing the output of strings
  2858.     // in the report file. Using the CStdioFile creates problem
  2859.     // under certain circumstances because the HTTP response header
  2860.     // already contains CRLF sequences.
  2861.     int nLen = sText.GetLength();
  2862.     pLogfile->Write(sText.GetBuffer(nLen + 1), nLen);
  2863.     sText.ReleaseBuffer();
  2864. }
  2865.  
  2866.  
  2867. void CFavOrgTreeCtl::StoreItemStatus(HTREEITEM hItem, BOOL bIsShortcut)
  2868. {
  2869.     CString sName = MakeFullItemName(hItem, bIsShortcut);
  2870.     int nState;
  2871.  
  2872.     // Store item state to map for further serialization
  2873.     if (bIsShortcut)
  2874.         nState = GetItemState(hItem, TVIS_STATEIMAGEMASK);
  2875.     else
  2876.         nState = GetItemState(hItem, TVIS_EXPANDED);
  2877.  
  2878.     sName.MakeUpper();
  2879.     m_StatusMap.SetAt(sName, nState);
  2880.  
  2881.     DWORD dwData = GetItemData(hItem);
  2882.     if ((dwData != 0) && (dwData != ITEM_IS_FOLDER))
  2883.         m_InfoMap.SetAt(sName, *((CString*) dwData));
  2884. }
  2885.  
  2886. void CFavOrgTreeCtl::StoreItemsStatus(HTREEITEM hItem)
  2887. {
  2888.     if (GetItemData(hItem) == ITEM_IS_FOLDER)
  2889.     {
  2890.         // It's a folder
  2891.         // Process all items in this folder
  2892.         StoreItemStatus(hItem, FALSE);
  2893.  
  2894.         HTREEITEM hChildItem = GetChildItem(hItem);
  2895.  
  2896.         while (hChildItem != NULL)
  2897.         {
  2898.             if (GetItemData(hChildItem) == ITEM_IS_FOLDER)
  2899.                 StoreItemsStatus(hChildItem);
  2900.             else
  2901.                 StoreItemStatus(hChildItem, TRUE);
  2902.             hChildItem = GetNextItem(hChildItem, TVGN_NEXT);
  2903.         }
  2904.     }
  2905.     else
  2906.         StoreItemStatus(hItem, TRUE);
  2907. }
  2908.  
  2909. void CFavOrgTreeCtl::StoreStatus()
  2910. {
  2911.     ClearSelection(TRUE);
  2912.  
  2913.     // Clear maps
  2914.     m_StatusMap.RemoveAll();
  2915.     m_InfoMap.RemoveAll();
  2916.  
  2917.     // Store individual items to map
  2918.     StoreItemsStatus(m_hRootItem);
  2919.  
  2920.     // Open file for map serialization
  2921.     CFile logfile;
  2922.     if(!logfile.Open(m_sStatusFile, CFile::modeCreate | CFile::modeWrite))
  2923.         return;
  2924.  
  2925.     try
  2926.     {
  2927.         // Serialize
  2928.         CArchive ar(&logfile, CArchive::store);
  2929.         m_StatusMap.Serialize(ar);
  2930.         ar.Close();
  2931.         logfile.Close();
  2932.  
  2933.         if(!logfile.Open(m_sInfoFile, CFile::modeCreate | CFile::modeWrite))
  2934.             return;
  2935.  
  2936.         CArchive arInfo(&logfile, CArchive::store);
  2937.         m_InfoMap.Serialize(arInfo);
  2938.         arInfo.Close();
  2939.         logfile.Close();
  2940.     }
  2941.  
  2942.     catch(CArchiveException* pEx)
  2943.     {
  2944.         pEx->Delete();
  2945.         logfile.Close();
  2946.         return;
  2947.     }
  2948. }
  2949.  
  2950. void CFavOrgTreeCtl::ProcessItemByState(HTREEITEM hItem, BOOL bAccessDenied, BOOL bTimeout, BOOL bPageNotFound, BOOL bSiteNone)
  2951. {
  2952.     int nActualState = GetItemState(hItem, TVIS_STATEIMAGEMASK) & ~0xFF;
  2953.  
  2954.     // If item has one of the user defined state, delete it
  2955.     if (((nActualState == INDEXTOSTATEIMAGEMASK(STATE_INDEX_ACCESSDENIED)) && bAccessDenied)
  2956.          ||
  2957.          ((nActualState == INDEXTOSTATEIMAGEMASK(STATE_INDEX_PAGENONE)) && bPageNotFound)
  2958.          ||
  2959.          ((nActualState == INDEXTOSTATEIMAGEMASK(STATE_INDEX_SITENONE)) && bSiteNone)
  2960.          ||
  2961.          ((nActualState == INDEXTOSTATEIMAGEMASK(STATE_INDEX_TIMEOUT)) && bTimeout))
  2962.     {
  2963.         DestroyItem(hItem, FALSE);
  2964.     }
  2965.  
  2966.     PeekAndYield();
  2967.  
  2968.     if (m_pProgressCtl)
  2969.         m_pProgressCtl->OffsetPos(1);
  2970. }
  2971.  
  2972. void CFavOrgTreeCtl::ProcessItemsByState(HTREEITEM hItem, BOOL bAccessDenied, BOOL bTimeout, BOOL bPageNotFound, BOOL bSiteNone)
  2973. {
  2974.     if (GetItemData(hItem) == ITEM_IS_FOLDER)
  2975.     {
  2976.         // It's a folder
  2977.         // Process all items in this folder
  2978.         HTREEITEM hChildItem = GetChildItem(hItem);
  2979.         HTREEITEM hNextItem;
  2980.  
  2981.         while (!m_bCancel && (hChildItem != NULL))
  2982.         {
  2983.             // Take care of deleted items while enumerating
  2984.             hNextItem = GetNextItem(hChildItem, TVGN_NEXT);
  2985.             if (GetItemData(hChildItem) == ITEM_IS_FOLDER)
  2986.                 ProcessItemsByState(hChildItem, bAccessDenied, bTimeout, bPageNotFound, bSiteNone);
  2987.             else
  2988.                 ProcessItemByState(hChildItem, bAccessDenied, bTimeout, bPageNotFound, bSiteNone);
  2989.             hChildItem = hNextItem;
  2990.         }
  2991.  
  2992.         if (m_bCancel)
  2993.             GetParent()->PostMessage(WM_CAN_UNLOCK, 0, 0);
  2994.     }
  2995.     else
  2996.         ProcessItemByState(hItem, bAccessDenied, bTimeout, bPageNotFound, bSiteNone);
  2997. }
  2998.  
  2999. void CFavOrgTreeCtl::DeleteByState()
  3000. {
  3001.     CByStateDlg dlg;
  3002.  
  3003.     dlg.m_pFavTree = this;
  3004.  
  3005.     // The user must select the relevant states
  3006.     if ((dlg.DoModal() == IDCANCEL)
  3007.         ||
  3008.         (!dlg.m_bAccessDenied && !dlg.m_bTimeOut && !dlg.m_bPageNotFound && !dlg.m_bSiteNone))
  3009.         return;
  3010.  
  3011.     m_bProcessing = TRUE;
  3012.  
  3013.     if (m_pProgressCtl)
  3014.     {
  3015.         m_pProgressCtl->SetRange32(0, m_nLoadedItems);
  3016.         m_pProgressCtl->SetStep(1);
  3017.         m_pProgressCtl->SetPos(0);
  3018.     }
  3019.  
  3020.     m_bCancel = FALSE;
  3021.  
  3022.     ClearSelection(TRUE);
  3023.     // Find all items having the specified state
  3024.     ProcessItemsByState(m_hRootItem, dlg.m_bAccessDenied, dlg.m_bTimeOut, dlg.m_bPageNotFound, dlg.m_bSiteNone);
  3025.  
  3026.     m_bCancel = FALSE;
  3027.     if (m_pProgressCtl)
  3028.         m_pProgressCtl->SetPos(0);
  3029.     ClearMsg();
  3030.  
  3031.     SetCursor(LoadCursor(NULL, IDC_ARROW));
  3032.     m_bProcessing = FALSE;
  3033. }
  3034.  
  3035. BOOL CFavOrgTreeCtl::IsIconOrBmp(BYTE* pBuffer, DWORD dwLen)
  3036. {
  3037.     // Quick and dirty check to see if we actually got
  3038.     // an icon or a bitmap
  3039.     ICONHEADER*            pIconHeader = (ICONHEADER*) pBuffer;
  3040.     ICONDIRENTRY*        pIconEntry = (ICONDIRENTRY*) (pBuffer + sizeof(WORD) * 3);
  3041.     BITMAPFILEHEADER*    pBmpHeader = (BITMAPFILEHEADER*) pBuffer;
  3042.  
  3043.     if ((pIconHeader->idType == 1)
  3044.         &&
  3045.         (pIconHeader->idReserved == 0)
  3046.         && 
  3047.         (dwLen >= sizeof(ICONHEADER) + sizeof(ICONDIRENTRY)) )
  3048.     {
  3049.         if (pIconEntry->dwImageOffset >= dwLen)
  3050.             goto checkifbmp;
  3051.  
  3052.         return TRUE;
  3053.     }
  3054.  
  3055.     // Not an icon
  3056. checkifbmp:
  3057.  
  3058.     BITMAPFILEHEADER* pBmpFileHeader = (BITMAPFILEHEADER*) pBuffer;
  3059.     BITMAPINFOHEADER* pBmpInfoHeader = (BITMAPINFOHEADER*) (pBuffer + sizeof(BITMAPFILEHEADER));
  3060.  
  3061.     if ((dwLen < sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER))
  3062.         ||
  3063.         (pBmpFileHeader->bfType != BM)
  3064.         ||
  3065.         (pBmpFileHeader->bfSize != dwLen))
  3066.         return FALSE;
  3067.  
  3068.     return TRUE;
  3069. }
  3070.  
  3071. void CFavOrgTreeCtl::CollapseOrExpandAll(HTREEITEM hItem, BOOL bCollapse)
  3072. {
  3073.     if (GetItemData(hItem) == ITEM_IS_FOLDER)
  3074.     {
  3075.         // It's a folder
  3076.         // Process all items in this folder
  3077.         Expand(hItem, bCollapse ? TVE_COLLAPSE : TVE_EXPAND);
  3078.  
  3079.         HTREEITEM hChildItem = GetChildItem(hItem);
  3080.  
  3081.         while (hChildItem != NULL)
  3082.         {
  3083.             if (GetItemData(hChildItem) == ITEM_IS_FOLDER)
  3084.                 CollapseOrExpandAll(hChildItem, bCollapse);
  3085.             hChildItem = GetNextItem(hChildItem, TVGN_NEXT);
  3086.         }
  3087.     }
  3088. }
  3089.  
  3090. void CFavOrgTreeCtl::ExpandAll()
  3091. {
  3092.     CollapseOrExpandAll(m_hRootItem, FALSE);
  3093.     EnsureVisible(m_hRootItem);
  3094. }
  3095.  
  3096. void CFavOrgTreeCtl::CollapseAll()
  3097. {
  3098.     CollapseOrExpandAll(m_hRootItem, TRUE);
  3099.     Expand(m_hRootItem, TVE_EXPAND);
  3100. }
  3101.  
  3102. void CFavOrgTreeCtl::ExpandCurrent()
  3103. {
  3104.     Expand(GetSelectedItem(), TVE_EXPAND);
  3105. }
  3106.  
  3107. void CFavOrgTreeCtl::CollapseCurrent()
  3108. {
  3109.     Expand(GetSelectedItem(), TVE_COLLAPSE);
  3110. }
  3111.  
  3112. void CFavOrgTreeCtl::OnVScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar) 
  3113. {
  3114.     m_bLetUserScroll = TRUE;
  3115.     
  3116.     CMultiselTreeCtrl::OnVScroll(nSBCode, nPos, pScrollBar);
  3117. }
  3118.  
  3119. void CFavOrgTreeCtl::OnHScroll(UINT nSBCode, UINT nPos, CScrollBar* pScrollBar) 
  3120. {
  3121.     m_bLetUserScroll = TRUE;
  3122.     
  3123.     CMultiselTreeCtrl::OnHScroll(nSBCode, nPos, pScrollBar);
  3124. }
  3125.